package com.sg.service.biz.app.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.sg.common.util.CommonFunctionHelper;
import com.sg.common.util.RedisUtil;
import com.sg.dto.base.app.req.*;
import com.sg.dto.biz.app.req.*;
import com.sg.dto.biz.app.res.*;
import com.sg.service.biz.app.*;
import com.sg.common.exception.Assert;
import com.wicket.okrapp.common.exception.BizException;
import com.wicket.okrcomponent.integration.InterfaceModeService;
import com.wicket.okrcomponent.integration.dto.*;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author ：
 * @version 1.0
 * @date ：
 */
@Service
public class ExecuteCycleServiceImpl
        implements com.wicket.okrapp.biz.service.ExecuteCycleService {

    @Resource
    private RedisUtil redisUtil;
    @Resource
    private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
    @Resource
    private MOmsExecuteCycleStageService mOmsExecuteCycleStageService;
    //@Resource
    //private MCustomFields3Service mCustomFields3Service;
    @Resource
    private MOmsTspeCycleStageDataService mOmsTspeCycleStageDataService;
    @Resource
    private NbExecuteCycle nbExecuteCycle;
    @Resource
    private MOmsCycleService mOmsCycleService;
    @Resource
    private InterfaceModeService interfaceModeService;
    @Resource
    private CycleStageDataService cycleStageDataService;
    @Resource
    private GridCalculateService gridCalculateService;
    @Resource
    private MOmsTaskService mOmsTaskService;
    @Resource
    private CustomExecutionCycleService customExecutionCycleService;
    @Resource
    private TargetCalcService targetCalcService;
    @Resource
    private TargetCycleService targetCycleService;

    /**
     * D3-执行周期回写目标周期ID(公共)[6707]
     * gen by moon at 5/22/2023, 3:48:20 AM
     */
    @Trace(operationName = "D3-执行周期回写目标周期ID(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementExecuteCycleWriteBackEvaObjectCycleIdComRespDto implementExecuteCycleWriteBackEvaObjectCycleIdCom(ImplementExecuteCycleWriteBackEvaObjectCycleIdComReqDto reqDto) {


        if ((reqDto != null && reqDto.getIsProcessCycleStage() != null && reqDto.getIsProcessCycleStage().equals("FALSE"))) {
            //if(D3-执行周期回写目标周期ID(公共).是否过程周期阶段 等于 否)  41767

            OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
            QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
            queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:944277_1_41769
            queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:944279_1_41769
            queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:944275_1_41769
            if (reqDto != null) {
                queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:944272_1_41769
                queryEvaObjTargetCycleDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:944273_1_41769
                queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:944274_1_41769
            }

            /*3-3-09查被评对象目标周期详情（通过周期ID）[2313]   */
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(), "D3-执行周期回写目标周期ID(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-被评对象内容表主键ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(), "D3-执行周期回写目标周期ID(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-被评对象类型编码不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(), "D3-执行周期回写目标周期ID(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-关联目标内容ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getCycleId(), "D3-执行周期回写目标周期ID(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-周期ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3-执行周期回写目标周期ID(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-冗余评价模板ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(), "D3-执行周期回写目标周期ID(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-是否存档不能为空", false);
            omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            boolean bOOLEAN;
            if (omsEvaluationObjectTargetCycle != null) {
                OmsExecuteCycleStage omsExecuteCycleStage = new OmsExecuteCycleStage();
                if (reqDto != null) {
                    omsExecuteCycleStage.setExecuteCycleStageId(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:943410_1_41770
                }
                if (omsEvaluationObjectTargetCycle != null) {
                    omsExecuteCycleStage.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:943411_1_41770
                }

                /*3-3-07修改执行周期阶段[2489]   */
                Assert.isNull(omsExecuteCycleStage.getExecuteCycleStageId(), "D3-执行周期回写目标周期ID(公共)-3-3-07修改执行周期阶段-执行周期阶段ID不能为空", false);
                Assert.isNull(omsExecuteCycleStage.getEvaObjTargetCycleId(), "D3-执行周期回写目标周期ID(公共)-3-3-07修改执行周期阶段-被评对象目标周期ID不能为空", false);
                bOOLEAN = mOmsExecuteCycleStageService.updateExecuteCycleStage(omsExecuteCycleStage)/*vcase invoke 本地 method 方法调用;*/;


            }
        } else if ((reqDto != null && reqDto.getIsProcessCycleStage() != null && reqDto.getIsProcessCycleStage().equals("TRUE"))) {
            //elseif(D3-执行周期回写目标周期ID(公共).是否过程周期阶段 等于 是)  41768

            OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
            QueryTargetCycleByStartAndEndTimeDetailReq queryTargetCycleByStartAndEndTimeDetailReq = new QueryTargetCycleByStartAndEndTimeDetailReq();
            queryTargetCycleByStartAndEndTimeDetailReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:944253_1_41771
            queryTargetCycleByStartAndEndTimeDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:944254_1_41771
            queryTargetCycleByStartAndEndTimeDetailReq.setIsSubCycle("TRUE");//sourceId:944256_1_41771
            queryTargetCycleByStartAndEndTimeDetailReq.setIsArchive("FALSE");//sourceId:944261_1_41771
            if (reqDto != null) {
                queryTargetCycleByStartAndEndTimeDetailReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:944255_1_41771
                queryTargetCycleByStartAndEndTimeDetailReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:944257_1_41771
                queryTargetCycleByStartAndEndTimeDetailReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:944258_1_41771
                queryTargetCycleByStartAndEndTimeDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:944259_1_41771
            }

            /*3-3-09查目标子周期By开始与结束时间[6551]   */
            Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getEvaObjEntityId(), "D3-执行周期回写目标周期ID(公共)-3-3-09查目标子周期By开始与结束时间-被评对象内容表主键ID不能为空", false);
            Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getEvaObjTypeCode(), "D3-执行周期回写目标周期ID(公共)-3-3-09查目标子周期By开始与结束时间-被评对象类型编码不能为空", false);
            Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getTargetCycleContentId(), "D3-执行周期回写目标周期ID(公共)-3-3-09查目标子周期By开始与结束时间-关联目标内容ID不能为空", false);
            Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getIsSubCycle(), "D3-执行周期回写目标周期ID(公共)-3-3-09查目标子周期By开始与结束时间-是否子周期不能为空", false);
            Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getCycleStartTime(), "D3-执行周期回写目标周期ID(公共)-3-3-09查目标子周期By开始与结束时间-目标计划开始时间不能为空", false);
            Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getCycleEndTime(), "D3-执行周期回写目标周期ID(公共)-3-3-09查目标子周期By开始与结束时间-目标计划结束时间不能为空", false);
            Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getEvaluationTemplateId(), "D3-执行周期回写目标周期ID(公共)-3-3-09查目标子周期By开始与结束时间-冗余评价模板ID不能为空", false);
            Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getIsArchive(), "D3-执行周期回写目标周期ID(公共)-3-3-09查目标子周期By开始与结束时间-是否存档不能为空", false);
            omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryTargetCycleByStartAndEndTimeDetail(queryTargetCycleByStartAndEndTimeDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            boolean bOOLEAN_1;
            if (omsEvaluationObjectTargetCycle_2 != null) {
                OmsExecuteCycleStage omsExecuteCycleStage_1 = new OmsExecuteCycleStage();
                if (reqDto != null) {
                    omsExecuteCycleStage_1.setExecuteCycleStageId(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:943410_1_41772
                }
                if (omsEvaluationObjectTargetCycle_2 != null) {
                    omsExecuteCycleStage_1.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:943411_1_41772
                }

                /*3-3-07修改执行周期阶段[2489]   */
                Assert.isNull(omsExecuteCycleStage_1.getExecuteCycleStageId(), "D3-执行周期回写目标周期ID(公共)-3-3-07修改执行周期阶段-执行周期阶段ID不能为空", false);
                Assert.isNull(omsExecuteCycleStage_1.getEvaObjTargetCycleId(), "D3-执行周期回写目标周期ID(公共)-3-3-07修改执行周期阶段-被评对象目标周期ID不能为空", false);
                bOOLEAN_1 = mOmsExecuteCycleStageService.updateExecuteCycleStage(omsExecuteCycleStage_1)/*vcase invoke 本地 method 方法调用;*/;


            }
        }
        ImplementExecuteCycleWriteBackEvaObjectCycleIdComRespDto retData = new ImplementExecuteCycleWriteBackEvaObjectCycleIdComRespDto();


        return retData;
    }

    /**
     * D3-查询执行周期详情（开始小于等于&结束大于等于）(公共)[7282]
     * gen by moon at 7/13/2023, 4:22:08 AM
     */
    @Trace(operationName = "D3-查询执行周期详情（开始小于等于&结束大于等于）(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryExecuteCycleLessStartBIgEndDetailComRespDto queryExecuteCycleLessStartBIgEndDetailCom(QueryExecuteCycleLessStartBIgEndDetailComReqDto reqDto) {


        OmsExecuteCycleStage omsExecuteCycleStage_1 = null;
//步骤0: 3-3-07-查执行周期时间详情（开始小于等于&结束大于等于） - queryExecuteCycleLessStartBIgEndDetail
        OmsExecuteCycleStage omsExecuteCycleStage = null;
        QueryExecuteCycleLessStartBIgEndDetailReq queryExecuteCycleLessStartBIgEndDetailReq = new QueryExecuteCycleLessStartBIgEndDetailReq();
        if (reqDto != null) {
            queryExecuteCycleLessStartBIgEndDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1074098_1
            queryExecuteCycleLessStartBIgEndDetailReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1074099_1
            queryExecuteCycleLessStartBIgEndDetailReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1074100_1
            queryExecuteCycleLessStartBIgEndDetailReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1074101_1
            queryExecuteCycleLessStartBIgEndDetailReq.setIsFatherCycle(reqDto.getIsFatherCycle());//SimpleFieldAssign//sourceId:1074102_1
            queryExecuteCycleLessStartBIgEndDetailReq.setIsSubCycle(reqDto.getIsSubCycle());//SimpleFieldAssign//sourceId:1074103_1
            queryExecuteCycleLessStartBIgEndDetailReq.setIsMetaphase(reqDto.getIsMetaphase());//SimpleFieldAssign//sourceId:1074104_1
            queryExecuteCycleLessStartBIgEndDetailReq.setIsProcessCycleStage(reqDto.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:1074105_1
            queryExecuteCycleLessStartBIgEndDetailReq.setIsDefinedExecuteCycleStage(reqDto.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:1074106_1
            queryExecuteCycleLessStartBIgEndDetailReq.setRelateContentTypeCode(reqDto.getRelateContentTypeCode());//SimpleFieldAssign//sourceId:1074107_1
            queryExecuteCycleLessStartBIgEndDetailReq.setRelateContentId(reqDto.getRelateContentId());//SimpleFieldAssign//sourceId:1074108_1
            queryExecuteCycleLessStartBIgEndDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1074109_1
            queryExecuteCycleLessStartBIgEndDetailReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:1074110_1
            queryExecuteCycleLessStartBIgEndDetailReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1074111_1
        }

        /*3-3-07-查执行周期时间详情（开始小于等于&结束大于等于）[7281]   */

        omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleLessStartBIgEndDetail(queryExecuteCycleLessStartBIgEndDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        omsExecuteCycleStage_1 = omsExecuteCycleStage;

        QueryExecuteCycleLessStartBIgEndDetailComRespDto retData = new QueryExecuteCycleLessStartBIgEndDetailComRespDto();
        if (omsExecuteCycleStage_1 != null) {
            retData.setExecuteCycleStageId(omsExecuteCycleStage_1.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1074128_1
            retData.setCycleId(omsExecuteCycleStage_1.getCycleId());//SimpleFieldAssign//sourceId:1074129_1
            retData.setCycleTypeCode(omsExecuteCycleStage_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:1085694_1
        }


        return retData;
    }

    /**
     * D3-执行更新周期时间切片分析(公共)[7293]
     * gen by moon at 7/20/2023, 4:34:44 PM
     */
    @Trace(operationName = "D3-执行更新周期时间切片分析(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementUpdateCycleTimeSliceAnalyzeComRespDto implementUpdateCycleTimeSliceAnalyzeCom(ImplementUpdateCycleTimeSliceAnalyzeComReqDto reqDto) {


        CalculateAcceptAboveFieldsRespDto receptionServiceRes_1 = null;
//virtualUsage 3-3-11查周期阶段资料详情  47764
        OmsTspeCycleStageData omsTspeCycleStageData = null;
        QueryCycleStageDataDetailReq queryCycleStageDataDetailReq = new QueryCycleStageDataDetailReq();
        queryCycleStageDataDetailReq.setCycleDataObjTypeCode("EVA_OBJ_TARGET_CYCLE");//sourceId:1082769_1_47764
        queryCycleStageDataDetailReq.setStageContentType("STA_WOR_SUM_CON");//sourceId:1082767_1_47764
        queryCycleStageDataDetailReq.setCycleDataTypeCode("CYC_STA_DAT");//sourceId:1082768_1_47764
        queryCycleStageDataDetailReq.setIsArchive("FALSE");//sourceId:1082772_1_47764
        if (reqDto != null) {
            queryCycleStageDataDetailReq.setCycleDataObjId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1082770_1_47764
            queryCycleStageDataDetailReq.setCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1082766_1_47764
            queryCycleStageDataDetailReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1082776_1_47764
        }

        /*3-3-11查周期阶段资料详情[2771]   */
        Assert.isNull(queryCycleStageDataDetailReq.getCycleDataObjId(), "D3-执行更新周期时间切片分析(公共)-3-3-11查周期阶段资料详情-周期资料归属对象ID不能为空", false);
        Assert.isNull(queryCycleStageDataDetailReq.getCycleDataObjTypeCode(), "D3-执行更新周期时间切片分析(公共)-3-3-11查周期阶段资料详情-周期资料归属对象类型编码不能为空", false);
        Assert.isNull(queryCycleStageDataDetailReq.getCycleId(), "D3-执行更新周期时间切片分析(公共)-3-3-11查周期阶段资料详情-周期ID不能为空", false);
        Assert.isNull(queryCycleStageDataDetailReq.getStageContentType(), "D3-执行更新周期时间切片分析(公共)-3-3-11查周期阶段资料详情-内容性质类型编码不能为空", false);
        Assert.isNull(queryCycleStageDataDetailReq.getCycleDataTypeCode(), "D3-执行更新周期时间切片分析(公共)-3-3-11查周期阶段资料详情-周期阶段资料类型编码不能为空", false);
        Assert.isNull(queryCycleStageDataDetailReq.getIsArchive(), "D3-执行更新周期时间切片分析(公共)-3-3-11查周期阶段资料详情-是否存档不能为空", false);
        Assert.isNull(queryCycleStageDataDetailReq.getThemeContentId(), "D3-执行更新周期时间切片分析(公共)-3-3-11查周期阶段资料详情-主题内容ID不能为空", false);
        omsTspeCycleStageData = mOmsTspeCycleStageDataService.queryCycleStageDataDetail(queryCycleStageDataDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((omsTspeCycleStageData != null)) {
            //if(3-3-11查周期阶段资料详情.出参 值不等于空 )  47765

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
            if (omsTspeCycleStageData != null) {
                CalculateAcceptAboveFieldsReqDto receptionServiceReq = new CalculateAcceptAboveFieldsReqDto();
                if (omsTspeCycleStageData != null) {
                    receptionServiceReq.setWorkCycleUpdateSlice(omsTspeCycleStageData.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1092139_1_47766
                }

                /*M3-约定出参：工作周期更新切片[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq.getWorkCycleUpdateSlice(), "D3-执行更新周期时间切片分析(公共)-M3-约定出参：工作周期更新切片-工作周期更新切片不能为空", false);
                receptionServiceRes = nbExecuteCycle.calculateAcceptAboveFields(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }
        } else if ((omsTspeCycleStageData == null)) {
            //elseif(3-3-11查周期阶段资料详情.出参 值等于空 )  47767

            ImplementAnalyseWorkCycleUpdateSliceComRespDto implementAnalyseWorkCycleUpdateSliceComRespDto = null;
            ImplementAnalyseWorkCycleUpdateSliceComReqDto implementAnalyseWorkCycleUpdateSliceComReqDto = new ImplementAnalyseWorkCycleUpdateSliceComReqDto();
            if (reqDto != null) {
                implementAnalyseWorkCycleUpdateSliceComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1092143_1_47768
                implementAnalyseWorkCycleUpdateSliceComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1092144_1_47768
                implementAnalyseWorkCycleUpdateSliceComReqDto.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1092142_1_47768
                implementAnalyseWorkCycleUpdateSliceComReqDto.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1092145_1_47768
            }

            /*D3-执行分析工作周期更新切片（公共）[6275]   */
            Assert.isNull(implementAnalyseWorkCycleUpdateSliceComReqDto.getEvaObjTargetCycleId(), "D3-执行更新周期时间切片分析(公共)-D3-执行分析工作周期更新切片（公共）-被评对象目标周期ID不能为空", false);
            Assert.isNull(implementAnalyseWorkCycleUpdateSliceComReqDto.getParentSubMidCycleType(), "D3-执行更新周期时间切片分析(公共)-D3-执行分析工作周期更新切片（公共）-父子中周期类型不能为空", false);
            Assert.isNull(implementAnalyseWorkCycleUpdateSliceComReqDto.getCycleStartTime(), "D3-执行更新周期时间切片分析(公共)-D3-执行分析工作周期更新切片（公共）-目标计划开始时间不能为空", false);
            Assert.isNull(implementAnalyseWorkCycleUpdateSliceComReqDto.getCycleEndTime(), "D3-执行更新周期时间切片分析(公共)-D3-执行分析工作周期更新切片（公共）-目标计划结束时间不能为空", false);
            implementAnalyseWorkCycleUpdateSliceComRespDto = cycleStageDataService.implementAnalyseWorkCycleUpdateSliceCom(implementAnalyseWorkCycleUpdateSliceComReqDto)/*vcase invoke isSameApp*/;


//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
            if (implementAnalyseWorkCycleUpdateSliceComRespDto != null) {
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_1 = new CalculateAcceptAboveFieldsReqDto();
                if (implementAnalyseWorkCycleUpdateSliceComRespDto != null) {
                    receptionServiceReq_1.setWorkCycleUpdateSlice(implementAnalyseWorkCycleUpdateSliceComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1092139_1_47769
                }

                /*M3-约定出参：工作周期更新切片[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_1.getWorkCycleUpdateSlice(), "D3-执行更新周期时间切片分析(公共)-M3-约定出参：工作周期更新切片-工作周期更新切片不能为空", false);
                receptionServiceRes_2 = nbExecuteCycle.calculateAcceptAboveFields(receptionServiceReq_1);


                receptionServiceRes_1 = receptionServiceRes_2;
            }
        }
        ImplementUpdateCycleTimeSliceAnalyzeComRespDto retData = new ImplementUpdateCycleTimeSliceAnalyzeComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setWorkCycleUpdateSlice(receptionServiceRes_1.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1092147_1
        }


        return retData;
    }

    /**
     * D3-执行相同周期类型当前及历史周期(公共)[7295]
     * gen by moon at 7/12/2023, 6:25:44 PM
     */
    @Trace(operationName = "D3-执行相同周期类型当前及历史周期(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCurrentAndHistoryCycleOfSameCycleTypeComRespDto implementCurrentAndHistoryCycleOfSameCycleTypeCom(ImplementCurrentAndHistoryCycleOfSameCycleTypeComReqDto reqDto) {


        CalculateAcceptAboveFieldsRespDto receptionServiceRes_1 = null;
//virtualUsage 3-4-04查询周期详情  47473
        OmsCycle omsCycle = null;
        QueryCycleDetailReq queryCycleDetailReq = new QueryCycleDetailReq();
        queryCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1085427_1_47473
        if (reqDto != null) {
            queryCycleDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1085426_1_47473
        }

        /*3-4-04查询周期详情[2004]   */
        Assert.isNull(queryCycleDetailReq.getCycleId(), "D3-执行相同周期类型当前及历史周期(公共)-3-4-04查询周期详情-周期ID不能为空", false);
        Assert.isNull(queryCycleDetailReq.getSubjectLifeCycle(), "D3-执行相同周期类型当前及历史周期(公共)-3-4-04查询周期详情-主体生命周期不能为空", false);
        omsCycle = mOmsCycleService.queryCycleDetail(queryCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//virtualUsage D2执行根据排序左右切数据(公共)  47472
        ImplementSplitDataBySortComRespDto implementSplitDataBySortComRespDto = null;
        if (omsCycle != null) {
            ImplementSplitDataBySortComReqDto implementSplitDataBySortComReqDto = new ImplementSplitDataBySortComReqDto();
            implementSplitDataBySortComReqDto.setCustomField1("FIND_BIG_DATA");//CUSTOM_CONVENTION//sourceId:1085169_1_47472
            if (reqDto != null && reqDto.getExecuteCycleStageList() != null && !CollectionUtil.isEmpty(reqDto.getExecuteCycleStageList())) {
                implementSplitDataBySortComReqDto.setComDatasList(//objList-to-objLists
                        reqDto.getExecuteCycleStageList().stream().map(item -> {
                            ComDatasDto elm = new ComDatasDto();
                            if (item != null) {
                                elm.setCommPrimaryKey(item.getCycleId());//SimpleFieldAssign//sourceId:228530_2_47472
                                elm.setCustomField2(item.getOrderNumber() != null ? String.valueOf(item.getOrderNumber()) : "");//SimpleFieldAssign//sourceId:228532_2_47472
                            }
                            return elm;
                        }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1085168_1_47472
            }
            if (omsCycle != null) {
                implementSplitDataBySortComReqDto.setCustomField2(omsCycle.getOrderNumber() != null ? String.valueOf(omsCycle.getOrderNumber()) : "");//SimpleFieldAssign//sourceId:1085170_1_47472
            }

            /*D2执行根据排序左右切数据(公共)[5866]   */
            Assert.isNull(implementSplitDataBySortComReqDto.getCustomField1(), "D3-执行相同周期类型当前及历史周期(公共)-D2执行根据排序左右切数据(公共)-区间找数据策略不能为空", false);
            Assert.isNull(implementSplitDataBySortComReqDto.getCustomField2(), "D3-执行相同周期类型当前及历史周期(公共)-D2执行根据排序左右切数据(公共)-自定义字段2不能为空", false);
            implementSplitDataBySortComRespDto = interfaceModeService.implementSplitDataBySortCom(implementSplitDataBySortComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
//virtualUsage D2执行数据集加一条记录(公共)  47474
        ImplementDataSetPlusOneComRespDto implementDataSetPlusOneComRespDto = null;
        if (implementSplitDataBySortComRespDto != null) {
            ImplementDataSetPlusOneComReqDto implementDataSetPlusOneComReqDto = new ImplementDataSetPlusOneComReqDto();
            if (implementSplitDataBySortComRespDto != null && implementSplitDataBySortComRespDto.getComDatasList() != null && !CollectionUtil.isEmpty(implementSplitDataBySortComRespDto.getComDatasList())) {
                implementDataSetPlusOneComReqDto.setDataSetPlusOneList(implementSplitDataBySortComRespDto.getComDatasList().stream().map(item -> item.getCommPrimaryKey())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1085423_1_47474
            }
            if (reqDto != null) {
                implementDataSetPlusOneComReqDto.setCommPrimaryKey(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1085424_1_47474
            }

            /*D2执行数据集加一条记录(公共)[5161]   */
            Assert.isNull(implementDataSetPlusOneComReqDto.getCommPrimaryKey(), "D3-执行相同周期类型当前及历史周期(公共)-D2执行数据集加一条记录(公共)-通用主键ID不能为空", false);
            implementDataSetPlusOneComRespDto = interfaceModeService.implementDataSetPlusOneCom(implementDataSetPlusOneComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
//virtualUsage 出参数据集：执行周期阶段列表  47476
        //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
        if (implementDataSetPlusOneComRespDto != null) {
            CalculateAcceptAboveFieldsReqDto receptionServiceReq = new CalculateAcceptAboveFieldsReqDto();
            if (implementDataSetPlusOneComRespDto != null) {
                //simpleList-to-objLists
                for (String item : implementDataSetPlusOneComRespDto.getDataSetPlusOneList()) {
                    ExecuteCycleStageDto oneItem = new ExecuteCycleStageDto();
                    if (implementDataSetPlusOneComRespDto != null) {
                        oneItem.setCycleId(item);//SimpleFieldAssign//sourceId:228668_2_47476
                    }

                    receptionServiceReq.getExecuteCycleStageList().add(oneItem);
                }//sourceId:1085655_1_47476
            }

            /*出参数据集：执行周期阶段列表[6495]  用于特殊方法接收上游入参。 */

            receptionServiceRes = nbExecuteCycle.calculateAcceptAboveFields(receptionServiceReq);


            receptionServiceRes_1 = receptionServiceRes;
        }
        ImplementCurrentAndHistoryCycleOfSameCycleTypeComRespDto retData = new ImplementCurrentAndHistoryCycleOfSameCycleTypeComRespDto();
        if (receptionServiceRes_1 != null && receptionServiceRes_1.getExecuteCycleStageList() != null && !CollectionUtil.isEmpty(receptionServiceRes_1.getExecuteCycleStageList())) {
            retData.setExecuteCycleStageList(receptionServiceRes_1.getExecuteCycleStageList().stream().map(item -> item.getCycleId())
                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:1085657_1
        }


        return retData;
    }

    /**
     * D3-查询最近可循环最大执行周期详情(公共)[7498]
     * gen by moon at 10/8/2023, 12:50:06 PM
     */
    @Trace(operationName = "D3-查询最近可循环最大执行周期详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryNextCycleMaxPeriodDetailComRespDto queryNextCycleMaxPeriodDetailCom(QueryNextCycleMaxPeriodDetailComReqDto reqDto) {


        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_1 = null;
        if ((reqDto != null && reqDto.getNextCyclePeriod() != null)) {
            //if(D3-查询最近可循环最大执行周期详情(公共).最近可循环周期类型编码 值不等于空 )  49683

            List<OmsExecuteCycleStage> listOmsExecuteCycleStage = new ArrayList<>();
            QuerySubCycleExecuteCycleStageListReq querySubCycleExecuteCycleStageListReq = new QuerySubCycleExecuteCycleStageListReq();
            querySubCycleExecuteCycleStageListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1162302_1_49685
            if (reqDto != null) {
                querySubCycleExecuteCycleStageListReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1162298_1_49685
                querySubCycleExecuteCycleStageListReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1162299_1_49685
                querySubCycleExecuteCycleStageListReq.setCycleTypeCode(reqDto.getNextCyclePeriod());//SimpleFieldAssign//sourceId:1162300_1_49685
                querySubCycleExecuteCycleStageListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1162301_1_49685
            }

            /*3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）[4718]   */
            Assert.isNull(querySubCycleExecuteCycleStageListReq.getCycleStartTime(), "D3-查询最近可循环最大执行周期详情(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-周期开始时间不能为空", false);
            Assert.isNull(querySubCycleExecuteCycleStageListReq.getCycleEndTime(), "D3-查询最近可循环最大执行周期详情(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-周期结束时间不能为空", false);
            Assert.isNull(querySubCycleExecuteCycleStageListReq.getCycleTypeCode(), "D3-查询最近可循环最大执行周期详情(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-周期类型标识不能为空", false);
            Assert.isNull(querySubCycleExecuteCycleStageListReq.getEvaluationTemplateId(), "D3-查询最近可循环最大执行周期详情(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-评价模板ID不能为空", false);
            Assert.isNull(querySubCycleExecuteCycleStageListReq.getSubjectLifeCycle(), "D3-查询最近可循环最大执行周期详情(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-主体生命周期不能为空", false);
            listOmsExecuteCycleStage = mOmsExecuteCycleStageService.querySubCycleExecuteCycleStageList(querySubCycleExecuteCycleStageListReq)/*vcase invoke 本地 method 方法调用;*/;


            if ((listOmsExecuteCycleStage != null && listOmsExecuteCycleStage != null && listOmsExecuteCycleStage.size() > 0)) {
                //if(3-3-07查时间范围内周或双周列表.执行周期阶段列表数据集条数 大于 0)  49690

                ImplementDataListGetMaxOrMiniByOrderNumberComRespDto implementDataListGetMaxOrMiniByOrderNumberComRespDto = null;
                if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage.size() > 0) {
                    ImplementDataListGetMaxOrMiniByOrderNumberComReqDto implementDataListGetMaxOrMiniByOrderNumberComReqDto = new ImplementDataListGetMaxOrMiniByOrderNumberComReqDto();
                    implementDataListGetMaxOrMiniByOrderNumberComReqDto.setOrderSizeType("FROM_SMALL_LARGE");//sourceId:1162312_1_49691
                    if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage)) {
                        implementDataListGetMaxOrMiniByOrderNumberComReqDto.setComDatasList(//objList-to-objLists
                                listOmsExecuteCycleStage.stream().map(item -> {
                                    ComDatasDto elm = new ComDatasDto();
                                    elm.setCustomField(item.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:241848_2_49691
                                    elm.setCustomField1(item.getCycleId());//SimpleFieldAssign//sourceId:241853_2_49691
                                    elm.setOrderNumber(item.getOrderNumber());//SimpleFieldAssign//sourceId:241849_2_49691
                                    return elm;
                                }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1162313_1_49691
                    }

                    /*D2-执行数据集根据排序字段取最大最小(公共)[7500]   */
                    Assert.isNull(implementDataListGetMaxOrMiniByOrderNumberComReqDto.getOrderSizeType(), "D3-查询最近可循环最大执行周期详情(公共)-D2-执行数据集根据排序字段取最大最小(公共)-排序大小类型不能为空", false);
                    implementDataListGetMaxOrMiniByOrderNumberComRespDto = interfaceModeService.implementDataListGetMaxOrMiniByOrderNumberCom(implementDataListGetMaxOrMiniByOrderNumberComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
//ModelCode: receptionService
                ImplementAcceptFieldByStandardDataRespDto receptionServiceRes = null;
                if (implementDataListGetMaxOrMiniByOrderNumberComRespDto != null) {
                    ImplementAcceptFieldByStandardDataReqDto receptionServiceReq = new ImplementAcceptFieldByStandardDataReqDto();
                    if (implementDataListGetMaxOrMiniByOrderNumberComRespDto != null) {
                        receptionServiceReq.setExecuteCycleStageId(implementDataListGetMaxOrMiniByOrderNumberComRespDto.getCustomField());//SimpleFieldAssign//sourceId:1162326_1_49692
                        receptionServiceReq.setCycleId(implementDataListGetMaxOrMiniByOrderNumberComRespDto.getCustomField1());//SimpleFieldAssign//sourceId:1162337_1_49692
                    }

                    /*约定出参：执行周期ID，周期ID[7478]  用于特殊方法接收上游入参。 */
                    Assert.isNull(receptionServiceReq.getExecuteCycleStageId(), "D3-查询最近可循环最大执行周期详情(公共)-约定出参：执行周期ID，周期ID-执行周期阶段ID不能为空", false);
                    Assert.isNull(receptionServiceReq.getCycleId(), "D3-查询最近可循环最大执行周期详情(公共)-约定出参：执行周期ID，周期ID-周期ID不能为空", false);
                    receptionServiceRes = nbExecuteCycle.implementAcceptFieldByStandardData(receptionServiceReq);


                    receptionServiceRes_1 = receptionServiceRes;
                }
            }
        } else {
            //else  49684

//异常结束 49687
            throw new BizException("500", "系统异常，请联系管理员！", false);
        }
        QueryNextCycleMaxPeriodDetailComRespDto retData = new QueryNextCycleMaxPeriodDetailComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setExecuteCycleStageId(receptionServiceRes_1.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1162328_1
            retData.setCycleId(receptionServiceRes_1.getCycleId());//SimpleFieldAssign//sourceId:1162341_1
        }


        return retData;
    }

    /**
     * D3获取当前目标内容执行周期(公共)[7501]
     * gen by moon at 5/7/2024, 11:20:15 PM
     */
    @Trace(operationName = "D3获取当前目标内容执行周期(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ObtainCurrentTargetContexeCuteCycleComRespDto obtainCurrentTargetContexeCuteCycleCom(ObtainCurrentTargetContexeCuteCycleComReqDto reqDto) {


        OmsExecuteCycleStage omsExecuteCycleStage_1 = null;
//virtualUsage 3-3-07查目标内容执行周期  49654
        OmsExecuteCycleStage omsExecuteCycleStage = null;
        QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq = new QueryExecuteCycleStageDetailReq();
        queryExecuteCycleStageDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1162663_1_49654
        if (reqDto != null) {
            queryExecuteCycleStageDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1162495_1_49654
            queryExecuteCycleStageDetailReq.setRelateContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1162496_1_49654
            queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1162498_1_49654
        }

        /*3-3-07查目标内容执行周期[2429]   */
        Assert.isNull(queryExecuteCycleStageDetailReq.getCycleId(), "D3获取当前目标内容执行周期(公共)-3-3-07查目标内容执行周期-周期ID不能为空", false);
        Assert.isNull(queryExecuteCycleStageDetailReq.getRelateContentId(), "D3获取当前目标内容执行周期(公共)-3-3-07查目标内容执行周期-关联目标内容ID不能为空", false);
        Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(), "D3获取当前目标内容执行周期(公共)-3-3-07查目标内容执行周期-评价模板ID不能为空", false);
        Assert.isNull(queryExecuteCycleStageDetailReq.getSubjectLifeCycle(), "D3获取当前目标内容执行周期(公共)-3-3-07查目标内容执行周期-主体生命周期不能为空", false);
        omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        omsExecuteCycleStage_1 = omsExecuteCycleStage;
        if ((omsExecuteCycleStage == null)) {
            //if(3-3-07查当前内容执行周期.出参 值等于空 )  49655

            OmsExecuteCycleStage omsExecuteCycleStage_2 = null;
            QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq_1 = new QueryExecuteCycleStageDetailReq();
            queryExecuteCycleStageDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1162663_1_49656
            if (reqDto != null) {
                queryExecuteCycleStageDetailReq_1.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1162495_1_49656
                queryExecuteCycleStageDetailReq_1.setRelateContentId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1162496_1_49656
                queryExecuteCycleStageDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1162498_1_49656
            }

            /*3-3-07查目标内容执行周期[2429]   */
            Assert.isNull(queryExecuteCycleStageDetailReq_1.getCycleId(), "D3获取当前目标内容执行周期(公共)-3-3-07查目标内容执行周期-周期ID不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq_1.getRelateContentId(), "D3获取当前目标内容执行周期(公共)-3-3-07查目标内容执行周期-关联目标内容ID不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq_1.getEvaluationTemplateId(), "D3获取当前目标内容执行周期(公共)-3-3-07查目标内容执行周期-评价模板ID不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq_1.getSubjectLifeCycle(), "D3获取当前目标内容执行周期(公共)-3-3-07查目标内容执行周期-主体生命周期不能为空", false);
            omsExecuteCycleStage_2 = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


            omsExecuteCycleStage_1 = omsExecuteCycleStage_2;
        }
        ObtainCurrentTargetContexeCuteCycleComRespDto retData = new ObtainCurrentTargetContexeCuteCycleComRespDto();
        if (omsExecuteCycleStage_1 != null) {
            retData.setExecuteCycleStageId(omsExecuteCycleStage_1.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1162501_1
            retData.setLastExecuteCycleStageId(omsExecuteCycleStage_1.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:1162502_1
            retData.setRelateExecuteCycleStageId(omsExecuteCycleStage_1.getRelateExecuteCycleStageId());//SimpleFieldAssign//sourceId:1162503_1
            retData.setEvaObjTargetCycleId(omsExecuteCycleStage_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1162504_1
            retData.setCycleId(omsExecuteCycleStage_1.getCycleId());//SimpleFieldAssign//sourceId:1162505_1
            retData.setCycleStandardName(omsExecuteCycleStage_1.getCycleStandardName());//SimpleFieldAssign//sourceId:1162506_1
            retData.setCycleStartTime(omsExecuteCycleStage_1.getCycleStartTime());//SimpleFieldAssign//sourceId:1162507_1
            retData.setCycleEndTime(omsExecuteCycleStage_1.getCycleEndTime());//SimpleFieldAssign//sourceId:1162508_1
            retData.setFillStartTime(omsExecuteCycleStage_1.getFillStartTime());//SimpleFieldAssign//sourceId:1162509_1
            retData.setFillEndtTime(omsExecuteCycleStage_1.getFillEndtTime());//SimpleFieldAssign//sourceId:1162510_1
            retData.setIsFatherCycle(omsExecuteCycleStage_1.getIsFatherCycle());//SimpleFieldAssign//sourceId:1162511_1
            retData.setIsSubCycle(omsExecuteCycleStage_1.getIsSubCycle());//SimpleFieldAssign//sourceId:1162512_1
            retData.setEvaluationTemplateId(omsExecuteCycleStage_1.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1162513_1
            retData.setCycleTypeCode(omsExecuteCycleStage_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:1162514_1
            retData.setRelateContentTypeCode(omsExecuteCycleStage_1.getRelateContentTypeCode());//SimpleFieldAssign//sourceId:1162515_1
            retData.setRelateContentId(omsExecuteCycleStage_1.getRelateContentId());//SimpleFieldAssign//sourceId:1162516_1
            retData.setTargetId(omsExecuteCycleStage_1.getTargetId());//SimpleFieldAssign//sourceId:1162517_1
            retData.setIsMetaphase(omsExecuteCycleStage_1.getIsMetaphase());//SimpleFieldAssign//sourceId:1162518_1
            retData.setIsProcessCycleStage(omsExecuteCycleStage_1.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:1162519_1
            retData.setIsDefinedExecuteCycleStage(omsExecuteCycleStage_1.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:1162520_1
            retData.setIsLastCycle(omsExecuteCycleStage_1.getIsLastCycle());//SimpleFieldAssign//sourceId:1162522_1
            retData.setEvaTempCreateTime(omsExecuteCycleStage_1.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:1162523_1
            retData.setIsCurrentCycle(omsExecuteCycleStage_1.getIsCurrentCycle());//SimpleFieldAssign//sourceId:1162524_1
            retData.setIsNextCycle(omsExecuteCycleStage_1.getIsNextCycle());//SimpleFieldAssign//sourceId:1162525_1
            retData.setNextCyclePeriod(omsExecuteCycleStage_1.getNextCyclePeriod());//SimpleFieldAssign//sourceId:1162526_1
            retData.setEvaluateStartTime(omsExecuteCycleStage_1.getEvaluateStartTime());//SimpleFieldAssign//sourceId:1162527_1
            retData.setEvaluateEndtTime(omsExecuteCycleStage_1.getEvaluateEndtTime());//SimpleFieldAssign//sourceId:1162528_1
            retData.setIsStartCycle(omsExecuteCycleStage_1.getIsStartCycle());//SimpleFieldAssign//sourceId:1162529_1
            retData.setIsEndCycle(omsExecuteCycleStage_1.getIsEndCycle());//SimpleFieldAssign//sourceId:1162530_1
        }


        return retData;
    }

    /**
     * D3-查询上一个执行周期的周期及目标周期详情(公共)[7507]
     * gen by moon at 10/26/2024, 7:39:46 PM
     */
    @Trace(operationName = "D3-查询上一个执行周期的周期及目标周期详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryLastExecCycleAndTargetCycleDetailComRespDto queryLastExecCycleAndTargetCycleDetailCom(QueryLastExecCycleAndTargetCycleDetailComReqDto reqDto) {


        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_1 = null;
        QueryTargetContexeCuteCycleDetailComRespDto queryTargetContexeCuteCycleDetailComRespDto_1 = null;
        ImplementAcceptFieldRespDto receptionServiceRes_1 = null;
//virtualUsage 3-3-09查被评对象目标周期详情（通过目标周期ID）  49766
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
        QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
        queryEvaObjTargetCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1166169_1_49766
        if (reqDto != null) {
            queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1166167_1_49766
            queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1166168_1_49766
        }

        /*3-3-09查被评对象目标周期详情（通过目标周期ID）[2313]   */
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(), "D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-09查被评对象目标周期详情（通过目标周期ID）-被评对象目标周期ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-09查被评对象目标周期详情（通过目标周期ID）-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getSubjectLifeCycle(), "D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-09查被评对象目标周期详情（通过目标周期ID）-主体生命周期不能为空", false);
        omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        omsEvaluationObjectTargetCycle_1 = omsEvaluationObjectTargetCycle;
//virtualUsage D3查询目标内容执行周期详情(公共)  69209
        QueryTargetContexeCuteCycleDetailComRespDto queryTargetContexeCuteCycleDetailComRespDto = null;
        QueryTargetContexeCuteCycleDetailComReqDto queryTargetContexeCuteCycleDetailComReqDto = new QueryTargetContexeCuteCycleDetailComReqDto();
        if (reqDto != null) {
            queryTargetContexeCuteCycleDetailComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1820389_1_69209
            queryTargetContexeCuteCycleDetailComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1820387_1_69209
            queryTargetContexeCuteCycleDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1820388_1_69209
        }

        /*D3查询目标内容执行周期详情(公共)[9661]   */
        Assert.isNull(queryTargetContexeCuteCycleDetailComReqDto.getCycleId(), "D3-查询上一个执行周期的周期及目标周期详情(公共)-D3查询目标内容执行周期详情(公共)-周期ID不能为空", false);
        Assert.isNull(queryTargetContexeCuteCycleDetailComReqDto.getEvaObjTargetCycleId(), "D3-查询上一个执行周期的周期及目标周期详情(公共)-D3查询目标内容执行周期详情(公共)-被评对象目标周期ID不能为空", false);
        Assert.isNull(queryTargetContexeCuteCycleDetailComReqDto.getEvaluationTemplateId(), "D3-查询上一个执行周期的周期及目标周期详情(公共)-D3查询目标内容执行周期详情(公共)-冗余评价模板ID不能为空", false);
        queryTargetContexeCuteCycleDetailComRespDto = queryTargetContexeCuteCycleDetailCom(queryTargetContexeCuteCycleDetailComReqDto)/*vcase invoke 同服务,同domain*/;


        queryTargetContexeCuteCycleDetailComRespDto_1 = queryTargetContexeCuteCycleDetailComRespDto;
        if ((queryTargetContexeCuteCycleDetailComRespDto != null && queryTargetContexeCuteCycleDetailComRespDto.getIsFatherCycle() != null && queryTargetContexeCuteCycleDetailComRespDto.getIsFatherCycle().equals("TRUE") || queryTargetContexeCuteCycleDetailComRespDto != null && queryTargetContexeCuteCycleDetailComRespDto.getIsMetaphase() != null && queryTargetContexeCuteCycleDetailComRespDto.getIsMetaphase().equals("TRUE"))) {
            //if((D3查询目标内容执行周期详情(公共).是否父周期 等于 是 or D3查询目标内容执行周期详情(公共).是否中期 等于 是))  49770

//processBranchName:正常结束 ,processBranchId:49771

        } else if ((queryTargetContexeCuteCycleDetailComRespDto != null && queryTargetContexeCuteCycleDetailComRespDto.getIsSubCycle() != null && queryTargetContexeCuteCycleDetailComRespDto.getIsSubCycle().equals("TRUE") && queryTargetContexeCuteCycleDetailComRespDto != null && queryTargetContexeCuteCycleDetailComRespDto.getIsFatherCycle() != null && queryTargetContexeCuteCycleDetailComRespDto.getIsFatherCycle().equals("FALSE") && queryTargetContexeCuteCycleDetailComRespDto != null && queryTargetContexeCuteCycleDetailComRespDto.getIsMetaphase() != null && queryTargetContexeCuteCycleDetailComRespDto.getIsMetaphase().equals("FALSE") && queryTargetContexeCuteCycleDetailComRespDto != null && queryTargetContexeCuteCycleDetailComRespDto.getLastExecuteCycleStageId() == null)) {
            //elseif((D3查询目标内容执行周期详情(公共).是否子周期 等于 是 and D3查询目标内容执行周期详情(公共).是否父周期 等于 否 and D3查询目标内容执行周期详情(公共).是否中期 等于 否 and D3查询目标内容执行周期详情(公共).上一执行周期阶段ID 值等于空 ))  49772

//processBranchName:正常结束 ,processBranchId:49773

        } else if ((queryTargetContexeCuteCycleDetailComRespDto != null && queryTargetContexeCuteCycleDetailComRespDto.getIsSubCycle() != null && queryTargetContexeCuteCycleDetailComRespDto.getIsSubCycle().equals("TRUE") && queryTargetContexeCuteCycleDetailComRespDto != null && queryTargetContexeCuteCycleDetailComRespDto.getIsFatherCycle() != null && queryTargetContexeCuteCycleDetailComRespDto.getIsFatherCycle().equals("FALSE") && queryTargetContexeCuteCycleDetailComRespDto != null && queryTargetContexeCuteCycleDetailComRespDto.getIsMetaphase() != null && queryTargetContexeCuteCycleDetailComRespDto.getIsMetaphase().equals("FALSE") && queryTargetContexeCuteCycleDetailComRespDto != null && queryTargetContexeCuteCycleDetailComRespDto.getLastExecuteCycleStageId() != null)) {
            //elseif((D3查询目标内容执行周期详情(公共).是否子周期 等于 是 and D3查询目标内容执行周期详情(公共).是否父周期 等于 否 and D3查询目标内容执行周期详情(公共).是否中期 等于 否 and D3查询目标内容执行周期详情(公共).上一执行周期阶段ID 值不等于空 ))  49774

            OmsExecuteCycleStage omsExecuteCycleStage = null;
            if (queryTargetContexeCuteCycleDetailComRespDto != null) {
                QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq = new QueryExecuteCycleStageDetailReq();
                queryExecuteCycleStageDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1166673_1_49781
                if (queryTargetContexeCuteCycleDetailComRespDto != null) {
                    queryExecuteCycleStageDetailReq.setExecuteCycleStageId(queryTargetContexeCuteCycleDetailComRespDto.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:1166671_1_49781
                }
                if (reqDto != null) {
                    queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1166672_1_49781
                }

                /*3-3-07查询执行周期阶段详情[2429]   */
                Assert.isNull(queryExecuteCycleStageDetailReq.getExecuteCycleStageId(), "D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-07查询执行周期阶段详情-执行周期阶段ID不能为空", false);
                Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(), "D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空", false);
                Assert.isNull(queryExecuteCycleStageDetailReq.getSubjectLifeCycle(), "D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-07查询执行周期阶段详情-主体生命周期不能为空", false);
                omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            }
            OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
            if (omsEvaluationObjectTargetCycle != null && omsExecuteCycleStage != null) {
                QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_1 = new QueryEvaObjTargetCycleDetailReq();
                queryEvaObjTargetCycleDetailReq_1.setIsSubCycle("TRUE");//sourceId:1166758_1_49783
                queryEvaObjTargetCycleDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1166760_1_49783
                if (omsEvaluationObjectTargetCycle != null) {
                    queryEvaObjTargetCycleDetailReq_1.setEvaObjEntityId(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1166753_1_49783
                    queryEvaObjTargetCycleDetailReq_1.setEvaObjTableTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:1166754_1_49783
                    queryEvaObjTargetCycleDetailReq_1.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1166755_1_49783
                    queryEvaObjTargetCycleDetailReq_1.setTreeTypeCode(omsEvaluationObjectTargetCycle.getTreeTypeCode());//SimpleFieldAssign//sourceId:1166756_1_49783
                    queryEvaObjTargetCycleDetailReq_1.setTargetCycleContentId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1166757_1_49783
                }
                if (omsExecuteCycleStage != null) {
                    queryEvaObjTargetCycleDetailReq_1.setCycleId(omsExecuteCycleStage.getCycleId());//SimpleFieldAssign//sourceId:1166761_1_49783
                }
                if (reqDto != null) {
                    queryEvaObjTargetCycleDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1166759_1_49783
                }

                /*3-3-09查被评对象目标周期详情（通过周期ID）[2313]   */
                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjEntityId(), "D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-被评对象内容表主键ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTableTypeCode(), "D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-被评对象内容表类型编码不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTypeCode(), "D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-被评对象类型编码不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getTreeTypeCode(), "D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-树类型编码不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getTargetCycleContentId(), "D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-关联目标内容ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getCycleId(), "D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-周期ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsSubCycle(), "D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-是否子周期不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaluationTemplateId(), "D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-冗余评价模板ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getSubjectLifeCycle(), "D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-主体生命周期不能为空", false);
                omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


            }
//ModelCode: receptionService
            ImplementAcceptFieldRespDto receptionServiceRes = null;
            if (omsEvaluationObjectTargetCycle_2 != null && omsExecuteCycleStage != null) {
                ImplementAcceptFieldReqDto receptionServiceReq = new ImplementAcceptFieldReqDto();
                if (omsEvaluationObjectTargetCycle_2 != null) {
                    receptionServiceReq.setLastEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1166615_1_49776
                }
                if (omsExecuteCycleStage != null) {
                    receptionServiceReq.setLastCycleId(omsExecuteCycleStage.getCycleId());//SimpleFieldAssign//sourceId:1166614_1_49776
                }

                /*约定出参：上一个执行周期-目标周期ID以及周期ID[6100]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq.getLastEvaObjTargetCycleId(), "D3-查询上一个执行周期的周期及目标周期详情(公共)-约定出参：上一个执行周期-目标周期ID以及周期ID-上一周期被评对象目标周期ID不能为空", false);
                Assert.isNull(receptionServiceReq.getLastCycleId(), "D3-查询上一个执行周期的周期及目标周期详情(公共)-约定出参：上一个执行周期-目标周期ID以及周期ID-上一周期ID不能为空", false);
                receptionServiceRes = nbExecuteCycle.implementAcceptField(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }
        } else if ((queryTargetContexeCuteCycleDetailComRespDto != null && queryTargetContexeCuteCycleDetailComRespDto.getIsProcessCycleStage() != null && queryTargetContexeCuteCycleDetailComRespDto.getIsProcessCycleStage().equals("TRUE") && queryTargetContexeCuteCycleDetailComRespDto != null && queryTargetContexeCuteCycleDetailComRespDto.getLastExecuteCycleStageId() == null)) {
            //elseif((D3查询目标内容执行周期详情(公共).是否过程周期阶段 等于 是 and D3查询目标内容执行周期详情(公共).上一执行周期阶段ID 值等于空 ))  49777

//processBranchName:正常结束 ,processBranchId:49778

        } else if ((queryTargetContexeCuteCycleDetailComRespDto != null && queryTargetContexeCuteCycleDetailComRespDto.getIsProcessCycleStage() != null && queryTargetContexeCuteCycleDetailComRespDto.getIsProcessCycleStage().equals("TRUE") && queryTargetContexeCuteCycleDetailComRespDto != null && queryTargetContexeCuteCycleDetailComRespDto.getLastExecuteCycleStageId() != null)) {
            //elseif((D3查询目标内容执行周期详情(公共).是否过程周期阶段 等于 是 and D3查询目标内容执行周期详情(公共).上一执行周期阶段ID 值不等于空 ))  49779

            OmsExecuteCycleStage omsExecuteCycleStage_2 = null;
            if (queryTargetContexeCuteCycleDetailComRespDto != null) {
                QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq_1 = new QueryExecuteCycleStageDetailReq();
                queryExecuteCycleStageDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1166673_1_49784
                if (queryTargetContexeCuteCycleDetailComRespDto != null) {
                    queryExecuteCycleStageDetailReq_1.setExecuteCycleStageId(queryTargetContexeCuteCycleDetailComRespDto.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:1166671_1_49784
                }
                if (reqDto != null) {
                    queryExecuteCycleStageDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1166672_1_49784
                }

                /*3-3-07查询执行周期阶段详情[2429]   */
                Assert.isNull(queryExecuteCycleStageDetailReq_1.getExecuteCycleStageId(), "D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-07查询执行周期阶段详情-执行周期阶段ID不能为空", false);
                Assert.isNull(queryExecuteCycleStageDetailReq_1.getEvaluationTemplateId(), "D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空", false);
                Assert.isNull(queryExecuteCycleStageDetailReq_1.getSubjectLifeCycle(), "D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-07查询执行周期阶段详情-主体生命周期不能为空", false);
                omsExecuteCycleStage_2 = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


            }
//ModelCode: receptionService
            ImplementAcceptFieldRespDto receptionServiceRes_2 = null;
            if (omsExecuteCycleStage_2 != null) {
                ImplementAcceptFieldReqDto receptionServiceReq_1 = new ImplementAcceptFieldReqDto();
                if (reqDto != null) {
                    receptionServiceReq_1.setLastEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1166615_1_49780
                }
                if (omsExecuteCycleStage_2 != null) {
                    receptionServiceReq_1.setLastCycleId(omsExecuteCycleStage_2.getCycleId());//SimpleFieldAssign//sourceId:1166614_1_49780
                }

                /*约定出参：上一个执行周期-目标周期ID以及周期ID[6100]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_1.getLastEvaObjTargetCycleId(), "D3-查询上一个执行周期的周期及目标周期详情(公共)-约定出参：上一个执行周期-目标周期ID以及周期ID-上一周期被评对象目标周期ID不能为空", false);
                Assert.isNull(receptionServiceReq_1.getLastCycleId(), "D3-查询上一个执行周期的周期及目标周期详情(公共)-约定出参：上一个执行周期-目标周期ID以及周期ID-上一周期ID不能为空", false);
                receptionServiceRes_2 = nbExecuteCycle.implementAcceptField(receptionServiceReq_1);


                receptionServiceRes_1 = receptionServiceRes_2;
            }
        }
        QueryLastExecCycleAndTargetCycleDetailComRespDto retData = new QueryLastExecCycleAndTargetCycleDetailComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setLastEvaObjTargetCycleId(receptionServiceRes_1.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1166762_1
            retData.setLastCycleId(receptionServiceRes_1.getLastCycleId());//SimpleFieldAssign//sourceId:1166763_1
        }
        if (omsEvaluationObjectTargetCycle_1 != null) {
            retData.setParentEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_1.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2024133_1
            retData.setEvaObjEntityId(omsEvaluationObjectTargetCycle_1.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1815758_1
            retData.setEvaObjTypeCode(omsEvaluationObjectTargetCycle_1.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1815759_1
            retData.setTargetCycleId(omsEvaluationObjectTargetCycle_1.getCycleId());//SimpleFieldAssign//sourceId:1914696_1
        }
        if (queryTargetContexeCuteCycleDetailComRespDto_1 != null) {
            retData.setCycleStartTime(queryTargetContexeCuteCycleDetailComRespDto_1.getCycleStartTime());//SimpleFieldAssign//sourceId:1820425_1
            retData.setCycleEndTime(queryTargetContexeCuteCycleDetailComRespDto_1.getCycleEndTime());//SimpleFieldAssign//sourceId:1820426_1
            retData.setCycleTypeCode(queryTargetContexeCuteCycleDetailComRespDto_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:1887547_1
            retData.setNextCyclePeriod(queryTargetContexeCuteCycleDetailComRespDto_1.getNextCyclePeriod());//SimpleFieldAssign//sourceId:1820428_1
            retData.setIsLastCycle(queryTargetContexeCuteCycleDetailComRespDto_1.getIsLastCycle());//SimpleFieldAssign//sourceId:1820427_1
        }


        return retData;
    }

    /**
     * D3执行过往执行周期是否末级处理(公共)[8774]
     * gen by moon at 4/30/2024, 2:33:07 AM
     */
    @Trace(operationName = "D3执行过往执行周期是否末级处理(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementWhetherPastExecutionPeriodIsLastDisposeComRespDto implementWhetherPastExecutionPeriodIsLastDisposeCom(ImplementWhetherPastExecutionPeriodIsLastDisposeComReqDto reqDto) {


        if ((reqDto != null && reqDto.getSecondLastCycleType() != null && !(reqDto != null && reqDto.getSecondLastCycleType() != null && reqDto.getSecondLastCycleType().equals("DISABLE")))) {
            //if((D3执行过往执行周期是否末级处理(公共).第二末级周期类型 值不等于空  and D3执行过往执行周期是否末级处理(公共).第二末级周期类型 不等于 不启用))  64968

            if ((reqDto != null && reqDto.getPeriodicModeTypeCode() != null && reqDto.getPeriodicModeTypeCode().equals("IRREGULAR_CYCLE") || reqDto != null && reqDto.getPeriodicModeTypeCode() != null && reqDto.getPeriodicModeTypeCode().equals("SINGLE_CYCLE"))) {
                //if((D3执行过往执行周期是否末级处理(公共).周期模式类型编码 等于 不规则周期 or D3执行过往执行周期是否末级处理(公共).周期模式类型编码 等于 单周期))  64972

                AnalysisReferenceTimeSecondCycleComRespDto analysisReferenceTimeSecondCycleComRespDto = null;
                AnalysisReferenceTimeSecondCycleComReqDto analysisReferenceTimeSecondCycleComReqDto = new AnalysisReferenceTimeSecondCycleComReqDto();
                analysisReferenceTimeSecondCycleComReqDto.setTargetCycleContentTypeCode("TARGET");//sourceId:1763768_1_67652
                analysisReferenceTimeSecondCycleComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1763770_1_67652
                if (reqDto != null) {
                    analysisReferenceTimeSecondCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1763769_1_67652
                }

                /*D3分析第二末级周期场景裁减时间(公共)[9463]   */
                Assert.isNull(analysisReferenceTimeSecondCycleComReqDto.getTargetCycleContentTypeCode(), "D3执行过往执行周期是否末级处理(公共)-D3分析第二末级周期场景裁减时间(公共)-关联目标内容类型编码不能为空", false);
                Assert.isNull(analysisReferenceTimeSecondCycleComReqDto.getEvaluationTemplateId(), "D3执行过往执行周期是否末级处理(公共)-D3分析第二末级周期场景裁减时间(公共)-冗余评价模板ID不能为空", false);
                Assert.isNull(analysisReferenceTimeSecondCycleComReqDto.getSpaceId(), "D3执行过往执行周期是否末级处理(公共)-D3分析第二末级周期场景裁减时间(公共)-创建于空间ID不能为空", false);
                analysisReferenceTimeSecondCycleComRespDto = customExecutionCycleService.analysisReferenceTimeSecondCycleCom(analysisReferenceTimeSecondCycleComReqDto)/*vcase invoke isSameApp*/;


                List<OmsExecuteCycleStage> listOmsExecuteCycleStage = new ArrayList<>();
                if (analysisReferenceTimeSecondCycleComRespDto != null) {
                    QuerySubCycleExecuteCycleStageListReq querySubCycleExecuteCycleStageListReq = new QuerySubCycleExecuteCycleStageListReq();
                    querySubCycleExecuteCycleStageListReq.setIsProcessCycleStage("TRUE");//sourceId:1658663_1_64974
                    querySubCycleExecuteCycleStageListReq.setRelateContentTypeCode("TARGET");//sourceId:1653393_1_64974
                    if (analysisReferenceTimeSecondCycleComRespDto != null) {
                        querySubCycleExecuteCycleStageListReq.setCycleEndTime(analysisReferenceTimeSecondCycleComRespDto.getComTimeField());//SimpleFieldAssign//sourceId:1653390_1_64974
                    }
                    if (reqDto != null) {
                        querySubCycleExecuteCycleStageListReq.setCycleTypeCode(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:1653391_1_64974
                        querySubCycleExecuteCycleStageListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1653394_1_64974
                    }

                    /*3-3-07查过往非末级过程执行周期列表（结束时间≤当前时间）[4718]   */
                    Assert.isNull(querySubCycleExecuteCycleStageListReq.getCycleEndTime(), "D3执行过往执行周期是否末级处理(公共)-3-3-07查过往非末级过程执行周期列表（结束时间≤当前时间）-周期结束时间不能为空", false);
                    Assert.isNull(querySubCycleExecuteCycleStageListReq.getCycleTypeCode(), "D3执行过往执行周期是否末级处理(公共)-3-3-07查过往非末级过程执行周期列表（结束时间≤当前时间）-周期类型标识不能为空", false);
                    Assert.isNull(querySubCycleExecuteCycleStageListReq.getIsProcessCycleStage(), "D3执行过往执行周期是否末级处理(公共)-3-3-07查过往非末级过程执行周期列表（结束时间≤当前时间）-是否过程周期阶段不能为空", false);
                    Assert.isNull(querySubCycleExecuteCycleStageListReq.getRelateContentTypeCode(), "D3执行过往执行周期是否末级处理(公共)-3-3-07查过往非末级过程执行周期列表（结束时间≤当前时间）-关联目标内容类型编码不能为空", false);
                    Assert.isNull(querySubCycleExecuteCycleStageListReq.getEvaluationTemplateId(), "D3执行过往执行周期是否末级处理(公共)-3-3-07查过往非末级过程执行周期列表（结束时间≤当前时间）-评价模板ID不能为空", false);
                    listOmsExecuteCycleStage = mOmsExecuteCycleStageService.querySubCycleExecuteCycleStageList(querySubCycleExecuteCycleStageListReq)/*vcase invoke 本地 method 方法调用;*/;


                }
                boolean bOOLEAN;
                if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage.size() > 0) {
                    List<String> listString = new ArrayList<>();
                    if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage)) {
                        listString = listOmsExecuteCycleStage.stream().map(item -> item.getExecuteCycleStageId())
                                .collect(Collectors.toList());/*list-to-strings*///sourceId:1653395_1_64975
                    }

                    /*3-3-07批量删执行周期阶段[2743]   */

                    bOOLEAN = mOmsExecuteCycleStageService.batchDeleteExecuteCycleStage(listString)/*vcase invoke 本地 method 方法调用;*/;


                }
                List<OmsExecuteCycleStage> listOmsExecuteCycleStage_2 = new ArrayList<>();
                if (analysisReferenceTimeSecondCycleComRespDto != null) {
                    QuerySubCycleExecuteCycleStageListReq querySubCycleExecuteCycleStageListReq_1 = new QuerySubCycleExecuteCycleStageListReq();
                    querySubCycleExecuteCycleStageListReq_1.setIsProcessCycleStage("TRUE");//sourceId:1658663_1_64976
                    querySubCycleExecuteCycleStageListReq_1.setRelateContentTypeCode("TARGET");//sourceId:1653393_1_64976
                    if (analysisReferenceTimeSecondCycleComRespDto != null) {
                        querySubCycleExecuteCycleStageListReq_1.setCycleEndTime(analysisReferenceTimeSecondCycleComRespDto.getComTimeField());//SimpleFieldAssign//sourceId:1653390_1_64976
                    }
                    if (reqDto != null) {
                        querySubCycleExecuteCycleStageListReq_1.setCycleTypeCode(reqDto.getSecondLastCycleType());//SimpleFieldAssign//sourceId:1653391_1_64976
                        querySubCycleExecuteCycleStageListReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1653394_1_64976
                    }

                    /*3-3-07查过往非末级过程执行周期列表（结束时间≤当前时间）[4718]   */
                    Assert.isNull(querySubCycleExecuteCycleStageListReq_1.getCycleEndTime(), "D3执行过往执行周期是否末级处理(公共)-3-3-07查过往非末级过程执行周期列表（结束时间≤当前时间）-周期结束时间不能为空", false);
                    Assert.isNull(querySubCycleExecuteCycleStageListReq_1.getCycleTypeCode(), "D3执行过往执行周期是否末级处理(公共)-3-3-07查过往非末级过程执行周期列表（结束时间≤当前时间）-周期类型标识不能为空", false);
                    Assert.isNull(querySubCycleExecuteCycleStageListReq_1.getIsProcessCycleStage(), "D3执行过往执行周期是否末级处理(公共)-3-3-07查过往非末级过程执行周期列表（结束时间≤当前时间）-是否过程周期阶段不能为空", false);
                    Assert.isNull(querySubCycleExecuteCycleStageListReq_1.getRelateContentTypeCode(), "D3执行过往执行周期是否末级处理(公共)-3-3-07查过往非末级过程执行周期列表（结束时间≤当前时间）-关联目标内容类型编码不能为空", false);
                    Assert.isNull(querySubCycleExecuteCycleStageListReq_1.getEvaluationTemplateId(), "D3执行过往执行周期是否末级处理(公共)-3-3-07查过往非末级过程执行周期列表（结束时间≤当前时间）-评价模板ID不能为空", false);
                    listOmsExecuteCycleStage_2 = mOmsExecuteCycleStageService.querySubCycleExecuteCycleStageList(querySubCycleExecuteCycleStageListReq_1)/*vcase invoke 本地 method 方法调用;*/;


                }
                boolean bOOLEAN_1;
                if (listOmsExecuteCycleStage_2 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2) && listOmsExecuteCycleStage_2.size() > 0) {
                    List<OmsExecuteCycleStage> listOmsExecuteCycleStage_3 = new ArrayList<>();
                    if (listOmsExecuteCycleStage_2 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2) && listOmsExecuteCycleStage_2 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2)) {
                        listOmsExecuteCycleStage_3 = //objList-to-objLists
                                listOmsExecuteCycleStage_2.stream().map(item -> {
                                    OmsExecuteCycleStage elm = new OmsExecuteCycleStage();
                                    elm.setExecuteCycleStageId(item.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:317653_2_64977
                                    elm.setIsLastCycle("TRUE");//sourceId:317667_2_64977
                                    elm.setNextCyclePeriod("---");//NULL//sourceId:317668_2_64977
                                    elm.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:317655_2_64977
                                    elm.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:317656_2_64977
                                    return elm;
                                }).collect(Collectors.toList());//objList-to-objLists//sourceId:1653396_1_64977
                    }

                    /*3-3-07批量改执行周期阶段[3150]   */

                    bOOLEAN_1 = mOmsExecuteCycleStageService.batchUpdateExecuteCycleStage(listOmsExecuteCycleStage_3)/*vcase invoke 本地 method 方法调用;*/;


                }
            } else if ((reqDto != null && reqDto.getPeriodicModeTypeCode() != null && reqDto.getPeriodicModeTypeCode().equals("FATHER_SON_CYCLE"))) {
                //elseif(D3执行过往执行周期是否末级处理(公共).周期模式类型编码 等于 父子周期)  64973

                OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
                QueryEvaObjTargetCycleEqualStartAndGreaterDetailReq queryEvaObjTargetCycleEqualStartAndGreaterDetailReq = new QueryEvaObjTargetCycleEqualStartAndGreaterDetailReq();
                queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1762167_1_67643
                queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1762168_1_67643
                queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setTargetCycleContentTypeCode("TARGET");//sourceId:1762169_1_67643
                queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setIsSubCycle("TRUE");//sourceId:1762170_1_67643
                queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setCycleStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1762171_1_67643
                queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setCycleEndTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1762172_1_67643
                queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setIsArchive("FALSE");//sourceId:1762174_1_67643
                if (reqDto != null) {
                    queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1762173_1_67643
                }

                /*3-3-09查目标的当前子周期开始时间（开始时间≤当前时间≥结束时间）[9460]   */
                Assert.isNull(queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.getEvaObjEntityId(), "D3执行过往执行周期是否末级处理(公共)-3-3-09查目标的当前子周期开始时间（开始时间≤当前时间≥结束时间）-被评对象内容表主键ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.getEvaObjTypeCode(), "D3执行过往执行周期是否末级处理(公共)-3-3-09查目标的当前子周期开始时间（开始时间≤当前时间≥结束时间）-被评对象类型编码不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.getTargetCycleContentTypeCode(), "D3执行过往执行周期是否末级处理(公共)-3-3-09查目标的当前子周期开始时间（开始时间≤当前时间≥结束时间）-关联目标内容类型编码不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.getCycleStartTime(), "D3执行过往执行周期是否末级处理(公共)-3-3-09查目标的当前子周期开始时间（开始时间≤当前时间≥结束时间）-目标计划开始时间不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.getCycleEndTime(), "D3执行过往执行周期是否末级处理(公共)-3-3-09查目标的当前子周期开始时间（开始时间≤当前时间≥结束时间）-目标计划结束时间不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.getEvaluationTemplateId(), "D3执行过往执行周期是否末级处理(公共)-3-3-09查目标的当前子周期开始时间（开始时间≤当前时间≥结束时间）-冗余评价模板ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.getIsArchive(), "D3执行过往执行周期是否末级处理(公共)-3-3-09查目标的当前子周期开始时间（开始时间≤当前时间≥结束时间）-是否存档不能为空", false);
                omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleEqualStartAndGreaterDetail(queryEvaObjTargetCycleEqualStartAndGreaterDetailReq)/*vcase invoke 本地 method 方法调用;*/;


                List<OmsExecuteCycleStage> listOmsExecuteCycleStage_4 = new ArrayList<>();
                if (omsEvaluationObjectTargetCycle != null) {
                    QuerySubCycleExecuteCycleStageListReq querySubCycleExecuteCycleStageListReq_2 = new QuerySubCycleExecuteCycleStageListReq();
                    querySubCycleExecuteCycleStageListReq_2.setIsProcessCycleStage("TRUE");//sourceId:1653497_1_64978
                    querySubCycleExecuteCycleStageListReq_2.setRelateContentTypeCode("TARGET");//sourceId:1653498_1_64978
                    if (omsEvaluationObjectTargetCycle != null) {
                        querySubCycleExecuteCycleStageListReq_2.setCycleEndTime(omsEvaluationObjectTargetCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:1653496_1_64978
                    }
                    if (reqDto != null) {
                        querySubCycleExecuteCycleStageListReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1653499_1_64978
                    }

                    /*3-3-07查询过往过程执行周期阶段列表（结束时间≤当前年开始时间）[4718]   */
                    Assert.isNull(querySubCycleExecuteCycleStageListReq_2.getCycleEndTime(), "D3执行过往执行周期是否末级处理(公共)-3-3-07查询过往过程执行周期阶段列表（结束时间≤当前年开始时间）-周期结束时间不能为空", false);
                    Assert.isNull(querySubCycleExecuteCycleStageListReq_2.getIsProcessCycleStage(), "D3执行过往执行周期是否末级处理(公共)-3-3-07查询过往过程执行周期阶段列表（结束时间≤当前年开始时间）-是否过程周期阶段不能为空", false);
                    Assert.isNull(querySubCycleExecuteCycleStageListReq_2.getRelateContentTypeCode(), "D3执行过往执行周期是否末级处理(公共)-3-3-07查询过往过程执行周期阶段列表（结束时间≤当前年开始时间）-关联目标内容类型编码不能为空", false);
                    Assert.isNull(querySubCycleExecuteCycleStageListReq_2.getEvaluationTemplateId(), "D3执行过往执行周期是否末级处理(公共)-3-3-07查询过往过程执行周期阶段列表（结束时间≤当前年开始时间）-评价模板ID不能为空", false);
                    listOmsExecuteCycleStage_4 = mOmsExecuteCycleStageService.querySubCycleExecuteCycleStageList(querySubCycleExecuteCycleStageListReq_2)/*vcase invoke 本地 method 方法调用;*/;


                }
                boolean bOOLEAN_2;
                if (listOmsExecuteCycleStage_4 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_4) && listOmsExecuteCycleStage_4.size() > 0) {
                    List<String> listString_1 = new ArrayList<>();
                    if (listOmsExecuteCycleStage_4 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_4) && listOmsExecuteCycleStage_4 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_4)) {
                        listString_1 = listOmsExecuteCycleStage_4.stream().map(item -> item.getExecuteCycleStageId())
                                .collect(Collectors.toList());/*list-to-strings*///sourceId:1653395_1_64979
                    }

                    /*3-3-07批量删执行周期阶段[2743]   */

                    bOOLEAN_2 = mOmsExecuteCycleStageService.batchDeleteExecuteCycleStage(listString_1)/*vcase invoke 本地 method 方法调用;*/;


                }
                List<OmsExecuteCycleStage> listOmsExecuteCycleStage_6 = new ArrayList<>();
                if (omsEvaluationObjectTargetCycle != null) {
                    QuerySubCycleExecuteCycleStageListReq querySubCycleExecuteCycleStageListReq_3 = new QuerySubCycleExecuteCycleStageListReq();
                    querySubCycleExecuteCycleStageListReq_3.setIsSubCycle("TRUE");//sourceId:1653522_1_64982
                    querySubCycleExecuteCycleStageListReq_3.setIsProcessCycleStage("FALSE");//sourceId:1653523_1_64982
                    querySubCycleExecuteCycleStageListReq_3.setRelateContentTypeCode("TARGET");//sourceId:1653524_1_64982
                    if (omsEvaluationObjectTargetCycle != null) {
                        querySubCycleExecuteCycleStageListReq_3.setCycleEndTime(omsEvaluationObjectTargetCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:1653521_1_64982
                    }
                    if (reqDto != null) {
                        querySubCycleExecuteCycleStageListReq_3.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1653525_1_64982
                    }

                    /*3-3-07查过往子周期执行周期阶段列表（结束时间≤当前年开始时间）[4718]   */
                    Assert.isNull(querySubCycleExecuteCycleStageListReq_3.getCycleEndTime(), "D3执行过往执行周期是否末级处理(公共)-3-3-07查过往子周期执行周期阶段列表（结束时间≤当前年开始时间）-周期结束时间不能为空", false);
                    Assert.isNull(querySubCycleExecuteCycleStageListReq_3.getIsSubCycle(), "D3执行过往执行周期是否末级处理(公共)-3-3-07查过往子周期执行周期阶段列表（结束时间≤当前年开始时间）-是否子周期不能为空", false);
                    Assert.isNull(querySubCycleExecuteCycleStageListReq_3.getIsProcessCycleStage(), "D3执行过往执行周期是否末级处理(公共)-3-3-07查过往子周期执行周期阶段列表（结束时间≤当前年开始时间）-是否过程周期阶段不能为空", false);
                    Assert.isNull(querySubCycleExecuteCycleStageListReq_3.getRelateContentTypeCode(), "D3执行过往执行周期是否末级处理(公共)-3-3-07查过往子周期执行周期阶段列表（结束时间≤当前年开始时间）-关联目标内容类型编码不能为空", false);
                    Assert.isNull(querySubCycleExecuteCycleStageListReq_3.getEvaluationTemplateId(), "D3执行过往执行周期是否末级处理(公共)-3-3-07查过往子周期执行周期阶段列表（结束时间≤当前年开始时间）-评价模板ID不能为空", false);
                    listOmsExecuteCycleStage_6 = mOmsExecuteCycleStageService.querySubCycleExecuteCycleStageList(querySubCycleExecuteCycleStageListReq_3)/*vcase invoke 本地 method 方法调用;*/;


                }
                boolean bOOLEAN_3;
                if (listOmsExecuteCycleStage_6 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_6) && listOmsExecuteCycleStage_6.size() > 0) {
                    List<OmsExecuteCycleStage> listOmsExecuteCycleStage_8 = new ArrayList<>();
                    if (listOmsExecuteCycleStage_6 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_6) && listOmsExecuteCycleStage_6 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_6)) {
                        listOmsExecuteCycleStage_8 = //objList-to-objLists
                                listOmsExecuteCycleStage_6.stream().map(item -> {
                                    OmsExecuteCycleStage elm = new OmsExecuteCycleStage();
                                    elm.setExecuteCycleStageId(item.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:317653_2_64983
                                    elm.setIsLastCycle("TRUE");//sourceId:317667_2_64983
                                    elm.setNextCyclePeriod("---");//NULL//sourceId:317668_2_64983
                                    elm.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:317655_2_64983
                                    elm.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:317656_2_64983
                                    return elm;
                                }).collect(Collectors.toList());//objList-to-objLists//sourceId:1653396_1_64983
                    }

                    /*3-3-07批量改执行周期阶段[3150]   */

                    bOOLEAN_3 = mOmsExecuteCycleStageService.batchUpdateExecuteCycleStage(listOmsExecuteCycleStage_8)/*vcase invoke 本地 method 方法调用;*/;


                }
            }
        }
        ImplementWhetherPastExecutionPeriodIsLastDisposeComRespDto retData = new ImplementWhetherPastExecutionPeriodIsLastDisposeComRespDto();


        return retData;
    }

    /**
     * D3分析上一个执行周期的周期及目标周期(公共)[9585]
     * gen by moon at 5/23/2024, 7:16:39 PM
     */
    @Trace(operationName = "D3分析上一个执行周期的周期及目标周期(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AnalysisLastExecCycleAndTargetCycleComRespDto analysisLastExecCycleAndTargetCycleCom(AnalysisLastExecCycleAndTargetCycleComReqDto reqDto) {


        QueryLastExecCycleAndTargetCycleDetailComRespDto queryLastExecCycleAndTargetCycleDetailComRespDto_1 = null;
        if ((reqDto != null && reqDto.getEvaObjTargetCycleId() != null)) {
            //if(D3分析上一个执行周期的周期及目标周期(公共).被评对象目标周期ID 值不等于空 )  68467

            QueryLastExecCycleAndTargetCycleDetailComRespDto queryLastExecCycleAndTargetCycleDetailComRespDto = null;
            QueryLastExecCycleAndTargetCycleDetailComReqDto queryLastExecCycleAndTargetCycleDetailComReqDto = new QueryLastExecCycleAndTargetCycleDetailComReqDto();
            if (reqDto != null) {
                queryLastExecCycleAndTargetCycleDetailComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1801677_1_68468
                queryLastExecCycleAndTargetCycleDetailComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1801678_1_68468
                queryLastExecCycleAndTargetCycleDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1801679_1_68468
            }

            /*D3-查询上一个执行周期的周期及目标周期详情(公共)[7507]   */
            Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getEvaObjTargetCycleId(), "D3分析上一个执行周期的周期及目标周期(公共)-D3-查询上一个执行周期的周期及目标周期详情(公共)-被评对象目标周期ID不能为空", false);
            Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getCycleId(), "D3分析上一个执行周期的周期及目标周期(公共)-D3-查询上一个执行周期的周期及目标周期详情(公共)-周期ID不能为空", false);
            Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getEvaluationTemplateId(), "D3分析上一个执行周期的周期及目标周期(公共)-D3-查询上一个执行周期的周期及目标周期详情(公共)-冗余评价模板ID不能为空", false);
            queryLastExecCycleAndTargetCycleDetailComRespDto = queryLastExecCycleAndTargetCycleDetailCom(queryLastExecCycleAndTargetCycleDetailComReqDto)/*vcase invoke 同服务,同domain*/;


            queryLastExecCycleAndTargetCycleDetailComRespDto_1 = queryLastExecCycleAndTargetCycleDetailComRespDto;
        }
        AnalysisLastExecCycleAndTargetCycleComRespDto retData = new AnalysisLastExecCycleAndTargetCycleComRespDto();
        if (queryLastExecCycleAndTargetCycleDetailComRespDto_1 != null) {
            retData.setLastEvaObjTargetCycleId(queryLastExecCycleAndTargetCycleDetailComRespDto_1.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1801814_1
            retData.setEvaObjEntityId(queryLastExecCycleAndTargetCycleDetailComRespDto_1.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1815762_1
            retData.setEvaObjTypeCode(queryLastExecCycleAndTargetCycleDetailComRespDto_1.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1815763_1
        }


        return retData;
    }

    /**
     * D3执行周期查询条件分析(公共)[9659]
     * gen by moon at 5/26/2024, 8:05:11 PM
     */
    @Trace(operationName = "D3执行周期查询条件分析(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementExecuteCycleConditionsComRespDto implementExecuteCycleConditionsCom(ImplementExecuteCycleConditionsComReqDto reqDto) {


        ImplementElevenReceivingFieldRespDto receptionServiceRes_1 = null;
        if ((reqDto != null && reqDto.getCycleTypeCode() != null && reqDto.getCycleTypeCode().equals("WEEK") || reqDto != null && reqDto.getCycleTypeCode() != null && reqDto.getCycleTypeCode().equals("DOUBLE_WEEKS"))) {
            //if((D3执行周及双周执行周期查询条件分析(公共).更新周期周期类型 等于 周 or D3执行周及双周执行周期查询条件分析(公共).更新周期周期类型 等于 双周))  69073

            if ((reqDto != null && reqDto.getIsOpenCustomExecuteCycle() != null && reqDto.getIsOpenCustomExecuteCycle().equals("TRUE"))) {
                //if(D3执行周及双周执行周期查询条件分析(公共).是否开启自定义执行周期 等于 是)  69076

//ModelCode: receptionService
                ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
                ImplementElevenReceivingFieldReqDto receptionServiceReq = new ImplementElevenReceivingFieldReqDto();
                if (reqDto != null) {
                    receptionServiceReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1817492_1_69078
                    receptionServiceReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1817493_1_69078
                }

                /*M3-接收出参字段[9482]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq.getTargetCycleContentId(), "D3执行周期查询条件分析(公共)-M3-接收出参字段-关联目标内容ID不能为空", false);
                receptionServiceRes = nbExecuteCycle.implementElevenReceivingField(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            } else if ((reqDto != null && reqDto.getIsOpenCustomExecuteCycle() != null && reqDto.getIsOpenCustomExecuteCycle().equals("FALSE"))) {
                //elseif(D3执行周及双周执行周期查询条件分析(公共).是否开启自定义执行周期 等于 否)  69077

                OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
                QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
                queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1817599_1_69086
                queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1817600_1_69086
                queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1817604_1_69086
                if (reqDto != null) {
                    queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1817601_1_69086
                    queryEvaObjTargetCycleDetailReq.setCycleId(reqDto.getOwnWorkCycleId());//SimpleFieldAssign//sourceId:1817602_1_69086
                    queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1817603_1_69086
                }

                /*3-3-09查目标的被评对象目标周期详情[2313]   */
                Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(), "D3执行周期查询条件分析(公共)-3-3-09查目标的被评对象目标周期详情-被评对象内容表主键ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(), "D3执行周期查询条件分析(公共)-3-3-09查目标的被评对象目标周期详情-被评对象类型编码不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(), "D3执行周期查询条件分析(公共)-3-3-09查目标的被评对象目标周期详情-关联目标内容ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq.getCycleId(), "D3执行周期查询条件分析(公共)-3-3-09查目标的被评对象目标周期详情-周期ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3执行周期查询条件分析(公共)-3-3-09查目标的被评对象目标周期详情-冗余评价模板ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(), "D3执行周期查询条件分析(公共)-3-3-09查目标的被评对象目标周期详情-是否存档不能为空", false);
                omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//ModelCode: receptionService
                ImplementElevenReceivingFieldRespDto receptionServiceRes_2 = null;
                if (omsEvaluationObjectTargetCycle != null) {
                    ImplementElevenReceivingFieldReqDto receptionServiceReq_1 = new ImplementElevenReceivingFieldReqDto();
                    if (omsEvaluationObjectTargetCycle != null) {
                        receptionServiceReq_1.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1817492_1_69079
                    }
                    if (reqDto != null) {
                        receptionServiceReq_1.setTargetCycleContentId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1817493_1_69079
                    }

                    /*M3-接收出参字段[9482]  用于特殊方法接收上游入参。 */
                    Assert.isNull(receptionServiceReq_1.getTargetCycleContentId(), "D3执行周期查询条件分析(公共)-M3-接收出参字段-关联目标内容ID不能为空", false);
                    receptionServiceRes_2 = nbExecuteCycle.implementElevenReceivingField(receptionServiceReq_1);


                    receptionServiceRes_1 = receptionServiceRes_2;
                }
            } else {
                //else  69087

//异常结束 69088
                throw new BizException("220100444", "对不起，目标内容的自定义执行周期数据异常~", false);
            }
        } else if ((!(reqDto != null && reqDto.getCycleTypeCode() != null && reqDto.getCycleTypeCode().equals("WEEK")) && !(reqDto != null && reqDto.getCycleTypeCode() != null && reqDto.getCycleTypeCode().equals("DOUBLE_WEEKS")))) {
            //elseif((D3执行周及双周执行周期查询条件分析(公共).更新周期周期类型 不等于 周 and D3执行周及双周执行周期查询条件分析(公共).更新周期周期类型 不等于 双周))  69074

            if ((reqDto != null && reqDto.getIsOpenCustomExecuteCycle() != null && reqDto.getIsOpenCustomExecuteCycle().equals("TRUE"))) {
                //if(D3执行周及双周执行周期查询条件分析(公共).是否开启自定义执行周期 等于 是)  69081

//ModelCode: receptionService
                ImplementElevenReceivingFieldRespDto receptionServiceRes_3 = null;
                ImplementElevenReceivingFieldReqDto receptionServiceReq_2 = new ImplementElevenReceivingFieldReqDto();
                if (reqDto != null) {
                    receptionServiceReq_2.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1817493_1_69083
                }

                /*M3-接收出参字段[9482]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_2.getTargetCycleContentId(), "D3执行周期查询条件分析(公共)-M3-接收出参字段-关联目标内容ID不能为空", false);
                receptionServiceRes_3 = nbExecuteCycle.implementElevenReceivingField(receptionServiceReq_2);


                receptionServiceRes_1 = receptionServiceRes_3;
            } else if ((reqDto != null && reqDto.getIsOpenCustomExecuteCycle() != null && reqDto.getIsOpenCustomExecuteCycle().equals("FALSE"))) {
                //elseif(D3执行周及双周执行周期查询条件分析(公共).是否开启自定义执行周期 等于 否)  69082

//ModelCode: receptionService
                ImplementElevenReceivingFieldRespDto receptionServiceRes_4 = null;
                ImplementElevenReceivingFieldReqDto receptionServiceReq_3 = new ImplementElevenReceivingFieldReqDto();
                if (reqDto != null) {
                    receptionServiceReq_3.setTargetCycleContentId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1817493_1_69084
                }

                /*M3-接收出参字段[9482]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_3.getTargetCycleContentId(), "D3执行周期查询条件分析(公共)-M3-接收出参字段-关联目标内容ID不能为空", false);
                receptionServiceRes_4 = nbExecuteCycle.implementElevenReceivingField(receptionServiceReq_3);


                receptionServiceRes_1 = receptionServiceRes_4;
            } else {
                //else  69089

//异常结束 69090
                throw new BizException("220100444", "对不起，目标内容的自定义执行周期数据异常~", false);
            }
        } else {
            //else  69092

//异常结束 69093
            throw new BizException("220100445", "对不起，更新周期的周期类型数据异常~", false);
        }
        ImplementExecuteCycleConditionsComRespDto retData = new ImplementExecuteCycleConditionsComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setEvaObjTargetCycleId(receptionServiceRes_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1817695_1
            retData.setTargetCycleContentId(receptionServiceRes_1.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1817696_1
        }


        return retData;
    }

    /**
     * D3查询目标内容执行周期详情(公共)[9661]
     * gen by moon at 6/6/2024, 4:20:33 PM
     */
    @Trace(operationName = "D3查询目标内容执行周期详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryTargetContexeCuteCycleDetailComRespDto queryTargetContexeCuteCycleDetailCom(QueryTargetContexeCuteCycleDetailComReqDto reqDto) {


        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_1 = null;
        QueryProcExecuteCycleStageDetailComRespDto queryProcExecuteCycleStageDetailComRespDto_1 = null;
        //步骤0: M3执行第十一接收字段（特殊方法） - implementElevenReceivingField
        //ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
        ImplementElevenReceivingFieldReqDto receptionServiceReq = new ImplementElevenReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1817884_1
            receptionServiceReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1818005_1
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1817886_1
        }

        /*M3-接收入参字段[9482]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getEvaObjTargetCycleId(), "D3查询目标内容执行周期详情(公共)-M3-接收入参字段-被评对象目标周期ID不能为空", false);
        Assert.isNull(receptionServiceReq.getCycleId(), "D3查询目标内容执行周期详情(公共)-M3-接收入参字段-周期ID不能为空", false);
        Assert.isNull(receptionServiceReq.getEvaluationTemplateId(), "D3查询目标内容执行周期详情(公共)-M3-接收入参字段-冗余评价模板ID不能为空", false);
        receptionServiceRes = nbExecuteCycle.implementElevenReceivingField(receptionServiceReq);


//步骤1: 3-3-09查被评对象目标周期详情 - queryEvaObjTargetCycleDetail
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
        QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
        queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1817979_1
        if (reqDto != null) {
            queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1817977_1
            queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1817978_1
        }

        /*3-3-09查入参目标周期详情（获取工作周期ID及目标内容ID、目标ID）[2313]   */
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(), "D3查询目标内容执行周期详情(公共)-3-3-09查入参目标周期详情（获取工作周期ID及目标内容ID、目标ID）-被评对象目标周期ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3查询目标内容执行周期详情(公共)-3-3-09查入参目标周期详情（获取工作周期ID及目标内容ID、目标ID）-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(), "D3查询目标内容执行周期详情(公共)-3-3-09查入参目标周期详情（获取工作周期ID及目标内容ID、目标ID）-是否存档不能为空", false);
        omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        omsEvaluationObjectTargetCycle_1 = omsEvaluationObjectTargetCycle;

//步骤2: D3准备目标内容扩展信息(公共) - preparationTargetContExtendInfoCom
        PreparationTargetContExtendInfoComRespDto preparationTargetContExtendInfoComRespDto = null;
        if (omsEvaluationObjectTargetCycle != null) {
            PreparationTargetContExtendInfoComReqDto preparationTargetContExtendInfoComReqDto = new PreparationTargetContExtendInfoComReqDto();
            if (omsEvaluationObjectTargetCycle != null) {
                preparationTargetContExtendInfoComReqDto.setTargetCycleContentId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1817832_1
                preparationTargetContExtendInfoComReqDto.setTargetCycleContentTypeCode(omsEvaluationObjectTargetCycle.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1817833_1
            }
            if (reqDto != null) {
                preparationTargetContExtendInfoComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1817834_1
            }

            /*D3查询目标内容扩展信息（获取目标内容是否开启自定义执行周期）[8590]   */
            Assert.isNull(preparationTargetContExtendInfoComReqDto.getTargetCycleContentId(), "D3查询目标内容执行周期详情(公共)-D3查询目标内容扩展信息（获取目标内容是否开启自定义执行周期）-关联目标内容ID不能为空", false);
            Assert.isNull(preparationTargetContExtendInfoComReqDto.getTargetCycleContentTypeCode(), "D3查询目标内容执行周期详情(公共)-D3查询目标内容扩展信息（获取目标内容是否开启自定义执行周期）-关联目标内容类型编码不能为空", false);
            Assert.isNull(preparationTargetContExtendInfoComReqDto.getEvaluationTemplateId(), "D3查询目标内容执行周期详情(公共)-D3查询目标内容扩展信息（获取目标内容是否开启自定义执行周期）-冗余评价模板ID不能为空", false);
            preparationTargetContExtendInfoComRespDto = targetCalcService.preparationTargetContExtendInfoCom(preparationTargetContExtendInfoComReqDto)/*vcase invoke isSameApp*/;


        }

//步骤3: 3-4-04查询周期详情 - queryCycleDetail
        OmsCycle omsCycle = null;
        QueryCycleDetailReq queryCycleDetailReq = new QueryCycleDetailReq();
        queryCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1820348_1
        if (reqDto != null) {
            queryCycleDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1820347_1
        }

        /*3-4-04查询周期详情（获取周期类型标识）[2004]   */
        Assert.isNull(queryCycleDetailReq.getCycleId(), "D3查询目标内容执行周期详情(公共)-3-4-04查询周期详情（获取周期类型标识）-周期ID不能为空", false);
        Assert.isNull(queryCycleDetailReq.getSubjectLifeCycle(), "D3查询目标内容执行周期详情(公共)-3-4-04查询周期详情（获取周期类型标识）-主体生命周期不能为空", false);
        omsCycle = mOmsCycleService.queryCycleDetail(queryCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤4: D3执行周期查询条件分析(公共) - implementExecuteCycleConditionsCom
        ImplementExecuteCycleConditionsComRespDto implementExecuteCycleConditionsComRespDto = null;
        if (omsEvaluationObjectTargetCycle != null) {
            ImplementExecuteCycleConditionsComReqDto implementExecuteCycleConditionsComReqDto = new ImplementExecuteCycleConditionsComReqDto();
            if (omsEvaluationObjectTargetCycle != null) {
                implementExecuteCycleConditionsComReqDto.setTargetId(omsEvaluationObjectTargetCycle.getTargetId());//SimpleFieldAssign//sourceId:1817988_1
                implementExecuteCycleConditionsComReqDto.setOwnWorkCycleId(omsEvaluationObjectTargetCycle.getCycleId());//SimpleFieldAssign//sourceId:1817986_1
                implementExecuteCycleConditionsComReqDto.setTargetCycleContentId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1817987_1
            }
            if (omsCycle != null) {
                implementExecuteCycleConditionsComReqDto.setCycleTypeCode(omsCycle.getCycleTypeCode());//SimpleFieldAssign//sourceId:1817842_1
            }
            if (reqDto != null) {
                implementExecuteCycleConditionsComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1817844_1
                implementExecuteCycleConditionsComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1817843_1
            }
            if (preparationTargetContExtendInfoComRespDto != null) {
                implementExecuteCycleConditionsComReqDto.setIsOpenCustomExecuteCycle(preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle());//SimpleFieldAssign//sourceId:1817847_1
            }

            /*D3执行周期查询条件分析(公共)[9659]   */
            Assert.isNull(implementExecuteCycleConditionsComReqDto.getTargetId(), "D3查询目标内容执行周期详情(公共)-D3执行周期查询条件分析(公共)-冗余目标ID不能为空", false);
            Assert.isNull(implementExecuteCycleConditionsComReqDto.getCycleTypeCode(), "D3查询目标内容执行周期详情(公共)-D3执行周期查询条件分析(公共)-周期类型标识不能为空", false);
            Assert.isNull(implementExecuteCycleConditionsComReqDto.getOwnWorkCycleId(), "D3查询目标内容执行周期详情(公共)-D3执行周期查询条件分析(公共)-归属工作周期ID不能为空", false);
            Assert.isNull(implementExecuteCycleConditionsComReqDto.getEvaObjTargetCycleId(), "D3查询目标内容执行周期详情(公共)-D3执行周期查询条件分析(公共)-被评对象目标周期ID不能为空", false);
            Assert.isNull(implementExecuteCycleConditionsComReqDto.getTargetCycleContentId(), "D3查询目标内容执行周期详情(公共)-D3执行周期查询条件分析(公共)-关联目标内容ID不能为空", false);
            Assert.isNull(implementExecuteCycleConditionsComReqDto.getIsOpenCustomExecuteCycle(), "D3查询目标内容执行周期详情(公共)-D3执行周期查询条件分析(公共)-是否开启自定义执行周期不能为空", false);
            Assert.isNull(implementExecuteCycleConditionsComReqDto.getEvaluationTemplateId(), "D3查询目标内容执行周期详情(公共)-D3执行周期查询条件分析(公共)-冗余评价模板ID不能为空", false);
            implementExecuteCycleConditionsComRespDto = implementExecuteCycleConditionsCom(implementExecuteCycleConditionsComReqDto)/*vcase invoke 同服务,同domain*/;


        }

//步骤5: D3-查询过程周期执行周期阶段详情(公共) - queryProcExecuteCycleStageDetailCom
        QueryProcExecuteCycleStageDetailComRespDto queryProcExecuteCycleStageDetailComRespDto = null;
        if (implementExecuteCycleConditionsComRespDto != null) {
            QueryProcExecuteCycleStageDetailComReqDto queryProcExecuteCycleStageDetailComReqDto = new QueryProcExecuteCycleStageDetailComReqDto();
            queryProcExecuteCycleStageDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1817995_1
            if (reqDto != null) {
                queryProcExecuteCycleStageDetailComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1817989_1
                queryProcExecuteCycleStageDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1817991_1
            }
            if (implementExecuteCycleConditionsComRespDto != null) {
                queryProcExecuteCycleStageDetailComReqDto.setRelateContentId(implementExecuteCycleConditionsComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1817990_1
                queryProcExecuteCycleStageDetailComReqDto.setEvaObjTargetCycleId(implementExecuteCycleConditionsComRespDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1817994_1
            }

            /*D3-查询执行周期阶段详情(公共)[6645]   */
            Assert.isNull(queryProcExecuteCycleStageDetailComReqDto.getCycleId(), "D3查询目标内容执行周期详情(公共)-D3-查询执行周期阶段详情(公共)-周期ID不能为空", false);
            Assert.isNull(queryProcExecuteCycleStageDetailComReqDto.getRelateContentId(), "D3查询目标内容执行周期详情(公共)-D3-查询执行周期阶段详情(公共)-关联目标内容ID不能为空", false);
            Assert.isNull(queryProcExecuteCycleStageDetailComReqDto.getEvaluationTemplateId(), "D3查询目标内容执行周期详情(公共)-D3-查询执行周期阶段详情(公共)-评价模板ID不能为空", false);
            Assert.isNull(queryProcExecuteCycleStageDetailComReqDto.getSubjectLifeCycle(), "D3查询目标内容执行周期详情(公共)-D3-查询执行周期阶段详情(公共)-主体生命周期不能为空", false);
            queryProcExecuteCycleStageDetailComRespDto = targetCycleService.queryProcExecuteCycleStageDetailCom(queryProcExecuteCycleStageDetailComReqDto)/*vcase invoke isSameApp*/;


            queryProcExecuteCycleStageDetailComRespDto_1 = queryProcExecuteCycleStageDetailComRespDto;
        }

        QueryTargetContexeCuteCycleDetailComRespDto retData = new QueryTargetContexeCuteCycleDetailComRespDto();


        if (queryProcExecuteCycleStageDetailComRespDto_1 != null) {
            retData.setExecuteCycleStageId(queryProcExecuteCycleStageDetailComRespDto_1.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1818960_1
            retData.setLastExecuteCycleStageId(queryProcExecuteCycleStageDetailComRespDto_1.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:1818961_1
            retData.setRelateExecuteCycleStageId(queryProcExecuteCycleStageDetailComRespDto_1.getRelateExecuteCycleStageId());//SimpleFieldAssign//sourceId:1818962_1
            retData.setEvaObjTargetCycleId(queryProcExecuteCycleStageDetailComRespDto_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1818963_1
            retData.setCycleId(queryProcExecuteCycleStageDetailComRespDto_1.getCycleId());//SimpleFieldAssign//sourceId:1818964_1
            retData.setCycleStandardName(queryProcExecuteCycleStageDetailComRespDto_1.getCycleStandardName());//SimpleFieldAssign//sourceId:1818965_1
            retData.setCycleStartTime(queryProcExecuteCycleStageDetailComRespDto_1.getCycleStartTime());//SimpleFieldAssign//sourceId:1818966_1
            retData.setCycleEndTime(queryProcExecuteCycleStageDetailComRespDto_1.getCycleEndTime());//SimpleFieldAssign//sourceId:1818967_1
            retData.setCycleTypeCode(queryProcExecuteCycleStageDetailComRespDto_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:1818968_1
            retData.setIsFatherCycle(queryProcExecuteCycleStageDetailComRespDto_1.getIsFatherCycle());//SimpleFieldAssign//sourceId:1818969_1
            retData.setIsMetaphase(queryProcExecuteCycleStageDetailComRespDto_1.getIsMetaphase());//SimpleFieldAssign//sourceId:1818970_1
            retData.setIsSubCycle(queryProcExecuteCycleStageDetailComRespDto_1.getIsSubCycle());//SimpleFieldAssign//sourceId:1818971_1
            retData.setIsProcessCycleStage(queryProcExecuteCycleStageDetailComRespDto_1.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:1818972_1
            retData.setIsLastCycle(queryProcExecuteCycleStageDetailComRespDto_1.getIsLastCycle());//SimpleFieldAssign//sourceId:1818973_1
            retData.setIsDefinedExecuteCycleStage(queryProcExecuteCycleStageDetailComRespDto_1.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:1818974_1
            retData.setNextCyclePeriod(queryProcExecuteCycleStageDetailComRespDto_1.getNextCyclePeriod());//SimpleFieldAssign//sourceId:1818975_1
            retData.setFillStartTime(queryProcExecuteCycleStageDetailComRespDto_1.getFillStartTime());//SimpleFieldAssign//sourceId:1818976_1
            retData.setFillEndtTime(queryProcExecuteCycleStageDetailComRespDto_1.getFillEndtTime());//SimpleFieldAssign//sourceId:1818977_1
            retData.setIsNextCycle(queryProcExecuteCycleStageDetailComRespDto_1.getIsNextCycle());//SimpleFieldAssign//sourceId:1818978_1
            retData.setIsCurrentCycle(queryProcExecuteCycleStageDetailComRespDto_1.getIsCurrentCycle());//SimpleFieldAssign//sourceId:1818979_1
            retData.setOrderNumber(queryProcExecuteCycleStageDetailComRespDto_1.getOrderNumber());//SimpleFieldAssign//sourceId:1818980_1
            retData.setEvaTempCreateTime(queryProcExecuteCycleStageDetailComRespDto_1.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:1818981_1
            retData.setRelateContentTypeCode(queryProcExecuteCycleStageDetailComRespDto_1.getRelateContentTypeCode());//SimpleFieldAssign//sourceId:1818982_1
            retData.setRelateContentId(queryProcExecuteCycleStageDetailComRespDto_1.getRelateContentId());//SimpleFieldAssign//sourceId:1818983_1
            retData.setTargetId(queryProcExecuteCycleStageDetailComRespDto_1.getTargetId());//SimpleFieldAssign//sourceId:1818984_1
            retData.setEvaluationTemplateId(queryProcExecuteCycleStageDetailComRespDto_1.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1818985_1
        }
        if (omsEvaluationObjectTargetCycle_1 != null) {
            retData.setEvaObjTargetCycleCode(omsEvaluationObjectTargetCycle_1.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1852097_1
        }


        return retData;
    }

    /**
     * D3查询执行周期阶段（时间从小到大）列表(公共)[9714]
     * gen by moon at 6/2/2024, 10:50:01 PM
     */
    @Trace(operationName = "D3查询执行周期阶段（时间从小到大）列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryExecuteCycleByTimeBigtoSmallListComRespDto queryExecuteCycleByTimeBigtoSmallListCom(QueryExecuteCycleByTimeBigtoSmallListComReqDto reqDto) {


        List<OmsExecuteCycleStage> listOmsExecuteCycleStage_1 = new ArrayList<>();
//步骤0: 3-3-07查询执行周期阶段（时间从小到大）列表 - queryExecuteCycleByTimeBigtoSmallList
        List<OmsExecuteCycleStage> listOmsExecuteCycleStage = new ArrayList<>();
        QueryExecuteCycleByTimeBigtoSmallListReq queryExecuteCycleByTimeBigtoSmallListReq = new QueryExecuteCycleByTimeBigtoSmallListReq();
        if (reqDto != null) {
            queryExecuteCycleByTimeBigtoSmallListReq.setRelateContentId(reqDto.getRelateContentId());//SimpleFieldAssign//sourceId:1840917_1
            queryExecuteCycleByTimeBigtoSmallListReq.setRelateContentTypeCode(reqDto.getRelateContentTypeCode());//SimpleFieldAssign//sourceId:1840922_1
            queryExecuteCycleByTimeBigtoSmallListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1840918_1
            queryExecuteCycleByTimeBigtoSmallListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1840919_1
            queryExecuteCycleByTimeBigtoSmallListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1840920_1
        }

        /*3-3-07查询执行周期阶段（时间从小到大）列表[8594]   */
        Assert.isNull(queryExecuteCycleByTimeBigtoSmallListReq.getSpaceId(), "D3查询执行周期阶段（时间从小到大）列表(公共)-3-3-07查询执行周期阶段（时间从小到大）列表-创建于空间ID不能为空", false);
        listOmsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleByTimeBigtoSmallList(queryExecuteCycleByTimeBigtoSmallListReq)/*vcase invoke 本地 method 方法调用;*/;


        listOmsExecuteCycleStage_1 = listOmsExecuteCycleStage;

        QueryExecuteCycleByTimeBigtoSmallListComRespDto retData = new QueryExecuteCycleByTimeBigtoSmallListComRespDto();
        retData.setExecuteCycleStageList(listOmsExecuteCycleStage_1.stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1840928_1


        return retData;
    }

    /**
     * D3查工作周期范围内执行周期详情（开始大于等于&结束小于等于）[7506]
     * gen by moon at 6/23/2024, 2:26:52 AM
     */
    @Trace(operationName = "D3查工作周期范围内执行周期详情（开始大于等于&结束小于等于）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryExecuteCycleBigStartLessEndDetailComRespDto queryExecuteCycleBigStartLessEndDetailCom(QueryExecuteCycleBigStartLessEndDetailComReqDto reqDto) {


        OmsExecuteCycleStage omsExecuteCycleStage_1 = null;
//步骤0: 3-3-07查执行周期时间范围详情（开始小于等于&结束大于等于） - queryExecuteCycleBigStartLessEndDetail
        OmsExecuteCycleStage omsExecuteCycleStage = null;
        QueryExecuteCycleBigStartLessEndDetailReq queryExecuteCycleBigStartLessEndDetailReq = new QueryExecuteCycleBigStartLessEndDetailReq();
        queryExecuteCycleBigStartLessEndDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1165583_1
        if (reqDto != null) {
            queryExecuteCycleBigStartLessEndDetailReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1887391_1
            queryExecuteCycleBigStartLessEndDetailReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1887392_1
            queryExecuteCycleBigStartLessEndDetailReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1887393_1
//queryExecuteCycleBigStartLessEndDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1887395_1
            queryExecuteCycleBigStartLessEndDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1165582_1
        }

        /*3-3-07查执行周期时间范围详情（开始小于等于&结束大于等于）[7505]   */
        Assert.isNull(queryExecuteCycleBigStartLessEndDetailReq.getCycleStartTime(), "D3查工作周期范围内执行周期详情（开始大于等于&结束小于等于）-3-3-07查执行周期时间范围详情（开始小于等于&结束大于等于）-周期开始时间不能为空", false);
        Assert.isNull(queryExecuteCycleBigStartLessEndDetailReq.getCycleEndTime(), "D3查工作周期范围内执行周期详情（开始大于等于&结束小于等于）-3-3-07查执行周期时间范围详情（开始小于等于&结束大于等于）-周期结束时间不能为空", false);
        Assert.isNull(queryExecuteCycleBigStartLessEndDetailReq.getCycleTypeCode(), "D3查工作周期范围内执行周期详情（开始大于等于&结束小于等于）-3-3-07查执行周期时间范围详情（开始小于等于&结束大于等于）-周期类型标识不能为空", false);
//Assert.isNull(queryExecuteCycleBigStartLessEndDetailReq.getEvaObjTargetCycleId(),"D3查工作周期范围内执行周期详情（开始大于等于&结束小于等于）-3-3-07查执行周期时间范围详情（开始小于等于&结束大于等于）-被评对象目标周期ID不能为空",false);
        Assert.isNull(queryExecuteCycleBigStartLessEndDetailReq.getEvaluationTemplateId(), "D3查工作周期范围内执行周期详情（开始大于等于&结束小于等于）-3-3-07查执行周期时间范围详情（开始小于等于&结束大于等于）-评价模板ID不能为空", false);
        Assert.isNull(queryExecuteCycleBigStartLessEndDetailReq.getSubjectLifeCycle(), "D3查工作周期范围内执行周期详情（开始大于等于&结束小于等于）-3-3-07查执行周期时间范围详情（开始小于等于&结束大于等于）-主体生命周期不能为空", false);
        omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleBigStartLessEndDetail(queryExecuteCycleBigStartLessEndDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        omsExecuteCycleStage_1 = omsExecuteCycleStage;

        QueryExecuteCycleBigStartLessEndDetailComRespDto retData = new QueryExecuteCycleBigStartLessEndDetailComRespDto();
        if (omsExecuteCycleStage_1 != null) {
            retData.setCycleStartTime(omsExecuteCycleStage_1.getCycleStartTime());//SimpleFieldAssign//sourceId:1887405_1
            retData.setCycleEndTime(omsExecuteCycleStage_1.getCycleEndTime());//SimpleFieldAssign//sourceId:1887406_1
        }


        return retData;
    }

    /**
     * D3查询执行周期阶段列表（开始大于等于&结束小于等于）[9850]
     * gen by moon at 7/10/2024, 6:45:21 PM
     */
    @Trace(operationName = "D3查询执行周期阶段列表（开始大于等于&结束小于等于）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryExecuteCycleBigStartLessEndListComRespDto queryExecuteCycleBigStartLessEndListCom(QueryExecuteCycleBigStartLessEndListComReqDto reqDto) {


        List<OmsExecuteCycleStage> listOmsExecuteCycleStage_1 = new ArrayList<>();
//步骤0: 3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于） - querySubCycleExecuteCycleStageList
        List<OmsExecuteCycleStage> listOmsExecuteCycleStage = new ArrayList<>();
        QuerySubCycleExecuteCycleStageListReq querySubCycleExecuteCycleStageListReq = new QuerySubCycleExecuteCycleStageListReq();
        if (reqDto != null) {
            querySubCycleExecuteCycleStageListReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1887268_1
            querySubCycleExecuteCycleStageListReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1887269_1
            querySubCycleExecuteCycleStageListReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1887270_1
            querySubCycleExecuteCycleStageListReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1887288_1
            querySubCycleExecuteCycleStageListReq.setRelateContentTypeCode(reqDto.getRelateContentTypeCode());//SimpleFieldAssign//sourceId:1925278_1
            querySubCycleExecuteCycleStageListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1887279_1
            querySubCycleExecuteCycleStageListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1887286_1
        }

        /*3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）[4718]   */
        Assert.isNull(querySubCycleExecuteCycleStageListReq.getCycleStartTime(), "D3查询执行周期阶段列表（开始大于等于&结束小于等于）-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-周期开始时间不能为空", false);
        Assert.isNull(querySubCycleExecuteCycleStageListReq.getCycleEndTime(), "D3查询执行周期阶段列表（开始大于等于&结束小于等于）-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-周期结束时间不能为空", false);
        Assert.isNull(querySubCycleExecuteCycleStageListReq.getEvaluationTemplateId(), "D3查询执行周期阶段列表（开始大于等于&结束小于等于）-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-评价模板ID不能为空", false);
        Assert.isNull(querySubCycleExecuteCycleStageListReq.getSubjectLifeCycle(), "D3查询执行周期阶段列表（开始大于等于&结束小于等于）-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-主体生命周期不能为空", false);
        listOmsExecuteCycleStage = mOmsExecuteCycleStageService.querySubCycleExecuteCycleStageList(querySubCycleExecuteCycleStageListReq)/*vcase invoke 本地 method 方法调用;*/;


        listOmsExecuteCycleStage_1 = listOmsExecuteCycleStage;

        QueryExecuteCycleBigStartLessEndListComRespDto retData = new QueryExecuteCycleBigStartLessEndListComRespDto();
        retData.setExecuteCycleStageList(listOmsExecuteCycleStage_1.stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1887303_1


        return retData;
    }

    /**
     * D3查询执行周期阶段列表（开始小于等于&结束大于等于）[9851]
     * gen by moon at 7/10/2024, 6:45:28 PM
     */
    @Trace(operationName = "D3查询执行周期阶段列表（开始小于等于&结束大于等于）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryExecuteCycleLessStartBIgEndListComRespDto queryExecuteCycleLessStartBIgEndListCom(QueryExecuteCycleLessStartBIgEndListComReqDto reqDto) {


        List<OmsExecuteCycleStage> listOmsExecuteCycleStage_1 = new ArrayList<>();
//步骤0: 3-3-07时间范围查询执行周期列表（开始小于等于&结束大于等于） - queryExecuteCycleLessStartBIgEndList
        List<OmsExecuteCycleStage> listOmsExecuteCycleStage = new ArrayList<>();
        QueryExecuteCycleLessStartBIgEndListReq queryExecuteCycleLessStartBIgEndListReq = new QueryExecuteCycleLessStartBIgEndListReq();
        if (reqDto != null) {
            queryExecuteCycleLessStartBIgEndListReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1887356_1
            queryExecuteCycleLessStartBIgEndListReq.setRelateContentTypeCode(reqDto.getRelateContentTypeCode());//SimpleFieldAssign//sourceId:1925282_1
            queryExecuteCycleLessStartBIgEndListReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1887357_1
            queryExecuteCycleLessStartBIgEndListReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1887358_1
            queryExecuteCycleLessStartBIgEndListReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1887434_1
            queryExecuteCycleLessStartBIgEndListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1887359_1
            queryExecuteCycleLessStartBIgEndListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1887360_1
        }

        /*3-3-07时间范围查询执行周期列表（开始小于等于&结束大于等于）[7222]   */
        Assert.isNull(queryExecuteCycleLessStartBIgEndListReq.getCycleStartTime(), "D3查询执行周期阶段列表（开始小于等于&结束大于等于）-3-3-07时间范围查询执行周期列表（开始小于等于&结束大于等于）-周期开始时间不能为空", false);
        Assert.isNull(queryExecuteCycleLessStartBIgEndListReq.getCycleEndTime(), "D3查询执行周期阶段列表（开始小于等于&结束大于等于）-3-3-07时间范围查询执行周期列表（开始小于等于&结束大于等于）-周期结束时间不能为空", false);
        Assert.isNull(queryExecuteCycleLessStartBIgEndListReq.getEvaluationTemplateId(), "D3查询执行周期阶段列表（开始小于等于&结束大于等于）-3-3-07时间范围查询执行周期列表（开始小于等于&结束大于等于）-评价模板ID不能为空", false);
        Assert.isNull(queryExecuteCycleLessStartBIgEndListReq.getSubjectLifeCycle(), "D3查询执行周期阶段列表（开始小于等于&结束大于等于）-3-3-07时间范围查询执行周期列表（开始小于等于&结束大于等于）-主体生命周期不能为空", false);
        listOmsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleLessStartBIgEndList(queryExecuteCycleLessStartBIgEndListReq)/*vcase invoke 本地 method 方法调用;*/;


        listOmsExecuteCycleStage_1 = listOmsExecuteCycleStage;

        QueryExecuteCycleLessStartBIgEndListComRespDto retData = new QueryExecuteCycleLessStartBIgEndListComRespDto();
        retData.setExecuteCycleStageList(listOmsExecuteCycleStage_1.stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1887367_1


        return retData;
    }

    /**
     * D3查询执行周期阶段列表(公共)[9854]
     * gen by moon at 8/26/2024, 1:18:44 PM
     */
    @Trace(operationName = "D3查询执行周期阶段列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryExecuteCycleByEvaTempListComRespDto queryExecuteCycleByEvaTempListCom(QueryExecuteCycleByEvaTempListComReqDto reqDto) {


        List<OmsExecuteCycleStage> listOmsExecuteCycleStage_1 = new ArrayList<>();
//步骤0: 3-3-07查询执行周期阶段列表 - queryExecuteCycleStageTestList
        List<OmsExecuteCycleStage> listOmsExecuteCycleStage = new ArrayList<>();
        QueryExecuteCycleStageTestListReq queryExecuteCycleStageTestListReq = new QueryExecuteCycleStageTestListReq();
        if (reqDto != null) {
            queryExecuteCycleStageTestListReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1887527_1
            queryExecuteCycleStageTestListReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1887525_1
            queryExecuteCycleStageTestListReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1887536_1
            queryExecuteCycleStageTestListReq.setRelateContentTypeCode(reqDto.getRelateContentTypeCode());//SimpleFieldAssign//sourceId:1925275_1
            queryExecuteCycleStageTestListReq.setRelateContentId(reqDto.getRelateContentId());//SimpleFieldAssign//sourceId:1933263_1
            queryExecuteCycleStageTestListReq.setIsProcessCycleStage(reqDto.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:1988286_1
            queryExecuteCycleStageTestListReq.setIsLastCycle(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:1933265_1
            queryExecuteCycleStageTestListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1887522_1
            queryExecuteCycleStageTestListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1887528_1
            queryExecuteCycleStageTestListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1887518_1
        }

        /*3-3-07查询执行周期阶段列表[4288]   */
        Assert.isNull(queryExecuteCycleStageTestListReq.getSubjectLifeCycle(), "D3查询执行周期阶段列表(公共)-3-3-07查询执行周期阶段列表-主体生命周期不能为空", false);
        Assert.isNull(queryExecuteCycleStageTestListReq.getSpaceId(), "D3查询执行周期阶段列表(公共)-3-3-07查询执行周期阶段列表-创建于空间ID不能为空", false);
        listOmsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageTestList(queryExecuteCycleStageTestListReq)/*vcase invoke 本地 method 方法调用;*/;


        listOmsExecuteCycleStage_1 = listOmsExecuteCycleStage;

        QueryExecuteCycleByEvaTempListComRespDto retData = new QueryExecuteCycleByEvaTempListComRespDto();
        retData.setExecuteCycleStageList(listOmsExecuteCycleStage_1.stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1887538_1


        return retData;
    }

    /**
     * D3批量查询执行周期阶段列表ByIds(公共)[9852]
     * gen by moon at 7/10/2024, 9:44:28 PM
     */
    @Trace(operationName = "D3批量查询执行周期阶段列表ByIds(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BatchQueryExecuteCycleByEvaTempListByIdsComRespDto batchQueryExecuteCycleByEvaTempListByIdsCom(BatchQueryExecuteCycleByEvaTempListByIdsComReqDto reqDto) {


        List<OmsExecuteCycleStage> listOmsExecuteCycleStage_1 = new ArrayList<>();
//步骤0: 3-3-07批量查执行周期列表（by执行周期ID） - batchQueryTargetCycleList
        List<OmsExecuteCycleStage> listOmsExecuteCycleStage = new ArrayList<>();
        BatchQueryTargetCycleListReq batchQueryTargetCycleListReq = new BatchQueryTargetCycleListReq();
        batchQueryTargetCycleListReq.setIsArchive("FALSE");//sourceId:1887440_1
        if (reqDto != null) {
            batchQueryTargetCycleListReq.setExecuteCycleStageList(reqDto.getExecuteCycleStageList());//list-field-assign//sourceId:1887438_1
            batchQueryTargetCycleListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1887442_1
            batchQueryTargetCycleListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1887441_1
        }

        /*3-3-07批量查执行周期列表（by执行周期ID）[2194]   */
        Assert.isNull(batchQueryTargetCycleListReq.getEvaluationTemplateId(), "D3批量查询执行周期阶段列表ByIds(公共)-3-3-07批量查执行周期列表（by执行周期ID）-评价模板ID不能为空", false);
        Assert.isNull(batchQueryTargetCycleListReq.getSubjectLifeCycle(), "D3批量查询执行周期阶段列表ByIds(公共)-3-3-07批量查执行周期列表（by执行周期ID）-主体生命周期不能为空", false);
        Assert.isNull(batchQueryTargetCycleListReq.getIsArchive(), "D3批量查询执行周期阶段列表ByIds(公共)-3-3-07批量查执行周期列表（by执行周期ID）-是否存档不能为空", false);
        listOmsExecuteCycleStage = mOmsExecuteCycleStageService.batchQueryTargetCycleList(batchQueryTargetCycleListReq)/*vcase invoke 本地 method 方法调用;*/;


        listOmsExecuteCycleStage_1 = listOmsExecuteCycleStage;

        BatchQueryExecuteCycleByEvaTempListByIdsComRespDto retData = new BatchQueryExecuteCycleByEvaTempListByIdsComRespDto();
        retData.setExecuteCycleStageList(listOmsExecuteCycleStage_1.stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1887446_1


        return retData;
    }

    /**
     * D3批量查询执行周期阶段By内容ID列表(公共)[9963]
     * gen by moon at 7/14/2024, 11:03:13 PM
     */
    @Trace(operationName = "D3批量查询执行周期阶段By内容ID列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BatchQueryExecuteCycleByContIdListByIdsComRespDto batchQueryExecuteCycleByContIdListByIdsCom(BatchQueryExecuteCycleByContIdListByIdsComReqDto reqDto) {


        List<OmsExecuteCycleStage> listOmsExecuteCycleStage_1 = new ArrayList<>();
//步骤0: 3-3-07批量查询执行周期阶段By内容ID列表 - batchQueryExecuteCycleByContIdListByIds
        List<OmsExecuteCycleStage> listOmsExecuteCycleStage = new ArrayList<>();
        BatchQueryExecuteCycleByContIdListByIdsReq batchQueryExecuteCycleByContIdListByIdsReq = new BatchQueryExecuteCycleByContIdListByIdsReq();
        if (reqDto != null) {
            batchQueryExecuteCycleByContIdListByIdsReq.setExecuteCycleStageList(reqDto.getExecuteCycleStageList());//list-field-assign//sourceId:1932892_1
            batchQueryExecuteCycleByContIdListByIdsReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1932893_1
            batchQueryExecuteCycleByContIdListByIdsReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1932894_1
            batchQueryExecuteCycleByContIdListByIdsReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1932895_1
        }

        /*3-3-07批量查询执行周期阶段By内容ID列表[9962]   */

        listOmsExecuteCycleStage = mOmsExecuteCycleStageService.batchQueryExecuteCycleByContIdListByIds(batchQueryExecuteCycleByContIdListByIdsReq)/*vcase invoke 本地 method 方法调用;*/;


        listOmsExecuteCycleStage_1 = listOmsExecuteCycleStage;

        BatchQueryExecuteCycleByContIdListByIdsComRespDto retData = new BatchQueryExecuteCycleByContIdListByIdsComRespDto();
        if (listOmsExecuteCycleStage_1 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_1) && listOmsExecuteCycleStage_1 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_1)) {
            retData.setExecuteCycleStageList(listOmsExecuteCycleStage_1.stream().map(item -> item.getExecuteCycleStageId())
                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:1932902_1
        }


        return retData;
    }

    /**
     * D3查询上一个执行周期的周期详情(公共)[9964]
     * gen by moon at 7/16/2024, 8:26:14 PM
     */
    @Trace(operationName = "D3查询上一个执行周期的周期详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryLastExecCycleDetailComRespDto queryLastExecCycleDetailCom(QueryLastExecCycleDetailComReqDto reqDto) {


        OmsExecuteCycleStage omsExecuteCycleStage_1 = null;
        if ((reqDto != null && reqDto.getLastExecuteCycleStageId() != null)) {
            //if(D3查询上一个执行周期的周期详情(公共).上一执行周期阶段ID 值不等于空 )  71612

            OmsExecuteCycleStage omsExecuteCycleStage = null;
            QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq = new QueryExecuteCycleStageDetailReq();
            if (reqDto != null) {
                queryExecuteCycleStageDetailReq.setExecuteCycleStageId(reqDto.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:1934232_1_71613
                queryExecuteCycleStageDetailReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1934234_1_71613
                queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1934233_1_71613
                queryExecuteCycleStageDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1934235_1_71613
            }

            /*3-3-07查询执行周期阶段详情[2429]   */

            omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            omsExecuteCycleStage_1 = omsExecuteCycleStage;
        }
        QueryLastExecCycleDetailComRespDto retData = new QueryLastExecCycleDetailComRespDto();
        if (omsExecuteCycleStage_1 != null) {
            retData.setExecuteCycleStageId(omsExecuteCycleStage_1.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1934236_1
            retData.setLastExecuteCycleStageId(omsExecuteCycleStage_1.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:1934237_1
            retData.setRelateExecuteCycleStageId(omsExecuteCycleStage_1.getRelateExecuteCycleStageId());//SimpleFieldAssign//sourceId:1934238_1
            retData.setEvaObjTargetCycleId(omsExecuteCycleStage_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1934239_1
            retData.setCycleId(omsExecuteCycleStage_1.getCycleId());//SimpleFieldAssign//sourceId:1934240_1
            retData.setCycleStandardName(omsExecuteCycleStage_1.getCycleStandardName());//SimpleFieldAssign//sourceId:1934241_1
            retData.setCycleTypeCode(omsExecuteCycleStage_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:1934242_1
            retData.setCycleTypeInstanceCode(omsExecuteCycleStage_1.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1934243_1
            retData.setCycleStartTime(omsExecuteCycleStage_1.getCycleStartTime());//SimpleFieldAssign//sourceId:1934244_1
            retData.setCycleEndTime(omsExecuteCycleStage_1.getCycleEndTime());//SimpleFieldAssign//sourceId:1934245_1
            retData.setFillStartTime(omsExecuteCycleStage_1.getFillStartTime());//SimpleFieldAssign//sourceId:1934246_1
            retData.setFillEndtTime(omsExecuteCycleStage_1.getFillEndtTime());//SimpleFieldAssign//sourceId:1934247_1
            retData.setIsFatherCycle(omsExecuteCycleStage_1.getIsFatherCycle());//SimpleFieldAssign//sourceId:1934248_1
            retData.setIsSubCycle(omsExecuteCycleStage_1.getIsSubCycle());//SimpleFieldAssign//sourceId:1934249_1
            retData.setRelateContentTypeCode(omsExecuteCycleStage_1.getRelateContentTypeCode());//SimpleFieldAssign//sourceId:1934250_1
            retData.setRelateContentId(omsExecuteCycleStage_1.getRelateContentId());//SimpleFieldAssign//sourceId:1934251_1
            retData.setTargetId(omsExecuteCycleStage_1.getTargetId());//SimpleFieldAssign//sourceId:1934252_1
            retData.setIsMetaphase(omsExecuteCycleStage_1.getIsMetaphase());//SimpleFieldAssign//sourceId:1934253_1
            retData.setIsProcessCycleStage(omsExecuteCycleStage_1.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:1934254_1
            retData.setIsDefinedExecuteCycleStage(omsExecuteCycleStage_1.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:1934255_1
            retData.setIsLastCycle(omsExecuteCycleStage_1.getIsLastCycle());//SimpleFieldAssign//sourceId:1934256_1
            retData.setIsCurrentCycle(omsExecuteCycleStage_1.getIsCurrentCycle());//SimpleFieldAssign//sourceId:1934257_1
            retData.setIsNextCycle(omsExecuteCycleStage_1.getIsNextCycle());//SimpleFieldAssign//sourceId:1934258_1
            retData.setNextCyclePeriod(omsExecuteCycleStage_1.getNextCyclePeriod());//SimpleFieldAssign//sourceId:1934259_1
            retData.setEvaluateStartTime(omsExecuteCycleStage_1.getEvaluateStartTime());//SimpleFieldAssign//sourceId:1934260_1
            retData.setEvaluateEndtTime(omsExecuteCycleStage_1.getEvaluateEndtTime());//SimpleFieldAssign//sourceId:1934261_1
            retData.setIsStartCycle(omsExecuteCycleStage_1.getIsStartCycle());//SimpleFieldAssign//sourceId:1934262_1
            retData.setIsEndCycle(omsExecuteCycleStage_1.getIsEndCycle());//SimpleFieldAssign//sourceId:1934263_1
            retData.setIsSameSceneCurrentSubCycle(omsExecuteCycleStage_1.getIsSameSceneCurrentSubCycle());//SimpleFieldAssign//sourceId:1934264_1
            retData.setEvaluationTemplateId(omsExecuteCycleStage_1.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1934265_1
            retData.setOrderNumber(omsExecuteCycleStage_1.getOrderNumber());//SimpleFieldAssign//sourceId:1934266_1
            retData.setEvaTempCreateTime(omsExecuteCycleStage_1.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:1934267_1
        }


        return retData;
    }
    //
}
